delete page from ui resultsadists

.gitignore

@@ -9,6 +9,8 @@
 *.class
 
 tmp
+mage8
+adists
 
 *.tar
 *.tar.*

.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.10 (pamhyr)" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.10 (pamhyr)" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/pamhyr.iml" filepath="$PROJECT_DIR$/.idea/pamhyr.iml" />
+    </modules>
+  </component>
+</project>

.idea/pamhyr.iml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/venv" />
+    </content>
+    <orderEntry type="jdk" jdkName="Python 3.10 (pamhyr)" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+  <component name="PyDocumentationSettings">
+    <option name="format" value="PLAIN" />
+    <option name="myDocStringFormat" value="Plain" />
+  </component>
+</module>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

doc/dev/documentation.org

@@ -646,7 +646,7 @@ class AddNodeCommand(QUndoCommand):
         self._node = node
 
     def undo(self):
-        self._graph.remove_node(self._node.name)
+        self._graph.remove_node(self._node)
 
     def redo(self):
         self._graph.insert_node(self._node)

full-requirements.txt

@@ -11,3 +11,4 @@ pyinstaller>=5.11.0
 shapely>=2.0.1
 lxml>=4.9.3
 platformdirs>=4.2.0
+pyshp>=2.3.1

requirements.txt

@@ -11,3 +11,4 @@ pyinstaller>=5.11.0
 shapely>=2.0.1
 lxml>=4.9.3
 platformdirs>=4.2.0
+pyshp>=2.3.1

src/Checker/Adists.py

@@ -0,0 +1,51 @@
+# Adists.py -- Pamhyr study checkers
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import time
+import logging
+from functools import reduce
+
+from PyQt5.QtCore import QCoreApplication
+
+from Modules import Modules
+from Checker.Checker import AbstractModelChecker, STATUS
+
+_translate = QCoreApplication.translate
+
+logger = logging.getLogger()
+
+class AdistsOutputKpChecker(AbstractModelChecker):
+    def __init__(self):
+        super(AdistsOutputKpChecker, self).__init__()
+
+        self._name = _translate("Checker", "AdisTS output Kp checker")
+        self._description = _translate(
+            "Checker", "Check output Kp"
+        )
+        self._modules = Modules.OUTPUT_KP
+
+    def run(self, study):
+        ok = True
+        nerror = 0
+        self._summary = "ok"
+        self._status = STATUS.OK
+
+        if not self.basic_check(study):
+            return False
+
+        return ok

src/Checker/Checker.py

@@ -92,6 +92,21 @@ class AbstractModelChecker(object):
     def is_error(self):
         return self._status == STATUS.ERROR
 
+    # Basic check
+    def basic_check(self, study):
+        if study is None:
+            self._status = STATUS.ERROR
+            self._summary = "invalid_study"
+            return False
+
+        river = study.river
+        if river is None:
+            self._status = STATUS.ERROR
+            self._summary = "no_river_found"
+            return False
+
+        return True
+
     # Abstract function
 
     def _run(self, study):

src/Checker/Study.py

@@ -17,6 +17,8 @@
 # -*- coding: utf-8 -*-
 
 import time
+import logging
+from functools import reduce
 
 from PyQt5.QtCore import QCoreApplication
 
@@ -25,6 +27,8 @@ from Checker.Checker import AbstractModelChecker, STATUS
 
 _translate = QCoreApplication.translate
 
+logger = logging.getLogger()
+
 
 class StudyNetworkReachChecker(AbstractModelChecker):
     def __init__(self):
@@ -37,16 +41,10 @@ class StudyNetworkReachChecker(AbstractModelChecker):
         self._modules = Modules.NETWORK
 
     def run(self, study):
-        if study is None:
-            self._status = STATUS.ERROR
-            self._summary = "invalid_study"
+        if not self.basic_check(study):
             return False
 
         river = study.river
-        if river is None:
-            self._status = STATUS.ERROR
-            self._summary = "no_river_found"
-            return False
 
         edges = list(filter(lambda e: e.is_enable(), river.edges()))
         if len(edges) == 0:
@@ -77,16 +75,10 @@ class StudyGeometryChecker(AbstractModelChecker):
         summary = "ok"
         status = STATUS.OK
 
-        if study is None:
-            self._status = STATUS.ERROR
-            self._summary = "invalid_study"
+        if not self.basic_check(study):
             return False
 
         river = study.river
-        if river is None:
-            self._status = STATUS.ERROR
-            self._summary = "no_river_found"
-            return False
 
         edges = river.enable_edges()
         if len(edges) == 0:
@@ -106,6 +98,124 @@ class StudyGeometryChecker(AbstractModelChecker):
         return ok
 
 
+class StudyInitialConditionsChecker(AbstractModelChecker):
+    def __init__(self):
+        super(StudyInitialConditionsChecker, self).__init__()
+
+        self._name = _translate("Checker", "Study initial conditions checker")
+        self._description = _translate(
+            "Checker", "Check initial conditions for each node of study"
+        )
+        self._modules = Modules.INITIAL_CONDITION
+
+    def run(self, study):
+        ok = True
+        nerror = 0
+        self._summary = "ok"
+        self._status = STATUS.OK
+
+        if not self.basic_check(study):
+            return False
+
+        for reach in study.river.enable_edges():
+            ok &= self.check_reach(study, reach.reach)
+
+        return ok
+
+    def check_reach(self, study, reach):
+        ok = True
+        river = study.river
+
+        if reach not in river.initial_conditions:
+            self._summary = "missing_initial_condition_defined"
+            self._status = STATUS.WARNING
+            return ok
+
+        ic = river.initial_conditions[reach]
+        len_ic = len(ic)
+        len_reach = len(reach)
+
+        if len_ic < len_reach:
+            self._summary = "initial_condition_missing_profile"
+            self._status = STATUS.WARNING
+
+        if len_ic > len_reach:
+            self._summary = "more_initial_condition_than_profile"
+            self._status = STATUS.ERROR
+            ok = False
+
+        return ok
+
+
+class StudyBoundaryConditionChecker(AbstractModelChecker):
+    def __init__(self):
+        super(StudyBoundaryConditionChecker, self).__init__()
+
+        self._name = _translate("Checker", "Study boundary conditions checker")
+        self._description = _translate(
+            "Checker", "Check boundary conditions for each node of study"
+        )
+        self._modules = Modules.BOUNDARY_CONDITION
+
+    def run(self, study):
+        ok = True
+        nerror = 0
+        self._summary = "ok"
+        self._status = STATUS.OK
+
+        if not self.basic_check(study):
+            return False
+
+        ok = self.check_liquid(study)
+
+        return ok
+
+    def check_liquid(self, study):
+        river = study.river
+
+        bcs = river.boundary_condition.get_tab('liquid')
+        if len(bcs) == 0:
+            self._status = STATUS.ERROR
+            self._summary = "no_boundary_condition_defined"
+            return False
+
+        upstream, downstream = reduce(
+            lambda acc, n: (
+                acc[0] + [n] if river.is_upstream_node(n) else acc[0],
+                acc[1] + [n] if river.is_downstream_node(n) else acc[1],
+            ),
+            filter(
+                lambda n: river.is_enable_node(n),
+                river.nodes()
+            ),
+            ([], [])
+        )
+
+        bcs_nodes = set(map(lambda bc: bc.node, bcs))
+
+        upstream_ok = self.check_liquid_all_node_has_bc(
+            bcs_nodes, upstream
+        )
+        downstream_ok = self.check_liquid_all_node_has_bc(
+            bcs_nodes, downstream
+        )
+
+        ok = upstream_ok and downstream_ok
+
+        if not ok:
+            self._status = STATUS.ERROR
+            self._summary = "no_boundary_condition_at_boundary_node"
+
+        return ok
+
+    def check_liquid_all_node_has_bc(self, bcs_nodes, nodes):
+        return reduce(
+            lambda acc, n: (acc and (n in bcs_nodes)),
+            nodes,
+            True
+        )
+
+
 class DummyOK(AbstractModelChecker):
     def __init__(self):
         super(DummyOK, self).__init__()

src/Meshing/Mage.py

@@ -293,10 +293,12 @@ class MeshingWithMageMailleurTT(AMeshingTool):
     def meshing(self, reach,
                 step: float = 50,
                 limites=[-1, -1],
+                origin=0,
                 directrices=['un', 'np'],
                 lplan: bool = False,
                 lm: int = 3,
-                linear: bool = False):
+                linear: bool = False,
+                origin_value=0.0):
         if reach is None or len(reach.profiles) == 0:
             return reach
 
@@ -305,32 +307,41 @@ class MeshingWithMageMailleurTT(AMeshingTool):
             st_file = self.export_reach_to_st(reach, tmp)
             m_file = st_file.rsplit(".ST", 1)[0] + ".M"
 
-            os.sync()
-
             proc = QProcess()
             proc.setWorkingDirectory(tmp)
 
+            # Mage section index start at 1
+            origin += 1
+            limites[0] += 1
+            limites[1] += 1
+
             lplan = 1 if lplan else 0
             linear = 1 if linear else 0
 
             logger.info(
-                f"! {self._exe_path()} {st_file} {m_file} " +
+                f"! {self._exe_path()} " +
+                f"{st_file} {m_file} " +
+                f"mesh " +
                 f"{str(step)} " +
                 f"{limites[0]} {limites[1]} " +
                 f"{directrices[0]} {directrices[1]} " +
-                f"{lplan} {lm} {linear}"
+                f"{lplan} {lm} {linear} " +
+                f"{origin} "
             )
             proc.start(
                 self._exe_path(),
-                list(map(
-                    str,
-                    [
-                        st_file, m_file, step,
-                        limites[0], limites[1],
-                        directrices[0], directrices[1],
-                        lplan, lm, linear
-                    ]
-                ))
+                list(
+                    map(
+                        str,
+                        [
+                            st_file, m_file,
+                            "mesh", step,
+                            limites[0], limites[1],
+                            directrices[0], directrices[1],
+                            lplan, lm, linear, origin, origin_value
+                        ]
+                    )
+                )
             )
             proc.waitForFinished()
 
@@ -347,9 +358,84 @@ class MeshingWithMageMailleurTT(AMeshingTool):
                 logger.error(
                     f"{logger_color_red()}{errors}{logger_color_reset()}"
                 )
-            else:
-                self.import_m_file(reach, m_file)
+                return reach
 
+            self.import_m_file(reach, m_file)
+            return reach
+
+    def update_kp(self, reach,
+                  step: float = 50,
+                  limites=[-1, -1],
+                  origin=0,
+                  directrices=['un', 'np'],
+                  lplan: bool = False,
+                  lm: int = 3,
+                  linear: bool = False,
+                  origin_value=0.0):
+        if reach is None or len(reach.profiles) == 0:
+            return reach
+
+        with tempfile.TemporaryDirectory() as tmp:
+            logger.debug(f"temp file: {tmp}")
+            st_file = self.export_reach_to_st(reach, tmp)
+            m_file = st_file.rsplit(".ST", 1)[0] + ".M"
+
+            os.sync()
+
+            proc = QProcess()
+            proc.setWorkingDirectory(tmp)
+
+            # Mage section indices start at 1
+            origin += 1
+            limites[0] += 1
+            limites[1] += 1
+
+            lplan = 1 if lplan else 0
+            linear = 1 if linear else 0
+
+            logger.info(
+                f"! {self._exe_path()} " +
+                f"{st_file} {m_file} " +
+                f"update_kp " +
+                f"{str(step)} " +
+                f"{limites[0]} {limites[1]} " +
+                f"{directrices[0]} {directrices[1]} " +
+                f"{lplan} {lm} {linear} " +
+                f"{origin} "
+            )
+            proc.start(
+                self._exe_path(),
+                list(
+                    map(
+                        str,
+                        [
+                            st_file, m_file,
+                            "update_kp", step,
+                            limites[0], limites[1],
+                            directrices[0], directrices[1],
+                            lplan, lm, linear, origin, origin_value
+                        ]
+                    )
+                )
+            )
+            proc.waitForFinished()
+
+            if proc.exitCode() != 0:
+                logger.error(
+                    f"{logger_color_red()}" +
+                    f"MailleurTT error: {proc.exitCode()}" +
+                    f"{logger_color_reset()}"
+                )
+                outputs = proc.readAllStandardOutput()
+                logger.debug(outputs)
+
+                errors = proc.readAllStandardError()
+                logger.error(
+                    f"{logger_color_red()}{errors}{logger_color_reset()}"
+                )
+                return reach
+
+            self.import_m_file(reach, m_file)
             return reach
 
     def export_reach_to_st(self, reach, tmp):

src/Model/BoundaryConditionsAdisTS/BoundaryConditionAdisTS.py

@@ -0,0 +1,221 @@
+# BoundaryConditionsAdisTS.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import logging
+
+from tools import (
+    trace, timer,
+    old_pamhyr_date_to_timestamp,
+    date_iso_to_timestamp,
+    date_dmy_to_timestamp,
+)
+
+from Model.Tools.PamhyrDB import SQLSubModel
+from Model.Except import NotImplementedMethodeError
+
+logger = logging.getLogger()
+
+
+class BoundaryConditionAdisTS(SQLSubModel):
+    _sub_classes = []
+    _id_cnt = 0
+
+    def __init__(self, id: int = -1,
+                 pollutant: int = -1, status=None):
+        super(BoundaryConditionAdisTS, self).__init__()
+
+        self._status = status
+
+        if id == -1:
+            self.id = BoundaryConditionAdisTS._id_cnt
+        else:
+            self.id = id
+
+        self._type = ""
+        self._node = None
+        self._pollutant = pollutant
+        self._data = []
+        self._header = []
+        self._types = [self.time_convert, float]
+
+        BoundaryConditionAdisTS._id_cnt = max(BoundaryConditionAdisTS._id_cnt + 1, self.id)
+
+    @classmethod
+    def _db_create(cls, execute):
+        execute("""
+          CREATE TABLE boundary_condition_adists(
+            id INTEGER NOT NULL PRIMARY KEY,
+            pollutant INTEGER NOT NULL,
+            type TEXT NOT NULL,
+            node INTEGER,
+            FOREIGN KEY(pollutant) REFERENCES Pollutants(id),
+            FOREIGN KEY(node) REFERENCES river_node(id)
+          )
+        """)
+
+        execute("""
+          CREATE TABLE boundary_condition_data_adists(
+            id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+            data0 TEXT NOT NULL,
+            data1 TEXT NOT NULL,
+            bc INTEGER,
+            FOREIGN KEY(bc) REFERENCES boundary_condition_adists(id)
+          )
+        """)
+
+        return cls._create_submodel(execute)
+
+    @classmethod
+    def _db_update(cls, execute, version):
+        return True
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = []
+
+        table = execute(
+            "SELECT id, pollutant, type, node " +
+            "FROM boundary_condition_adists"
+        )
+
+        if table is not None:
+            for row in table:
+                bc = cls(
+                    id=row[0],
+                    pollutant=row[1],
+                    status=data['status']
+                )
+
+                bc.type = row[2]
+
+                bc.node = None
+                if row[3] != -1:
+                    bc.node = next(filter(lambda n: n.id == row[3], data["nodes"])).id
+
+                values = execute(
+                    "SELECT data0, data1 FROM boundary_condition_data_adists " +
+                    f"WHERE bc = '{bc.id}'"
+                )
+
+                # Write data
+                for v in values:
+                    data0 = bc._types[0](v[0])
+                    data1 = bc._types[1](v[1])
+                    # Replace data at pos ind
+                    bc._data.append((data0, data1))
+
+                new.append(bc)
+
+        return new
+
+    def _db_save(self, execute, data=None):
+
+        execute(f"DELETE FROM boundary_condition_adists WHERE id = {self.id}")
+        execute(f"DELETE FROM boundary_condition_data_adists WHERE bc = {self.id}")
+
+        node = -1
+        if self._node is not None:
+            node = self._node
+
+        sql = (
+            "INSERT INTO " +
+            "boundary_condition_adists(id, pollutant, type, node) " +
+            "VALUES (" +
+            f"{self.id}, {self._pollutant}, " +
+            f"'{self._db_format(self._type)}', {node}" +
+            ")"
+        )
+        execute(sql)
+
+        for d in self._data:
+            data0 = self._db_format(str(d[0]))
+            data1 = self._db_format(str(d[1]))
+
+            sql = (
+                "INSERT INTO " +
+                "boundary_condition_data_adists(data0, data1, bc) " +
+                f"VALUES ('{data0}', {data1}, {self.id})"
+            )
+            execute(sql)
+
+        return True
+
+    def __len__(self):
+        return len(self._data)
+
+    @classmethod
+    def time_convert(cls, data):
+        if type(data) is str:
+            if data.count("-") == 2:
+                return date_iso_to_timestamp(data)
+            if data.count("/") == 2:
+                return date_dmy_to_timestamp(data)
+            if data.count(":") == 3:
+                return old_pamhyr_date_to_timestamp(data)
+            if data.count(":") == 2:
+                return old_pamhyr_date_to_timestamp("00:" + data)
+            if data.count(".") == 1:
+                return round(float(data))
+
+        return int(data)
+
+    @property
+    def node(self):
+        return self._node
+
+    @node.setter
+    def node(self, node):
+        self._node = node
+        self._status.modified()
+
+    @property
+    def header(self):
+        return self._header.copy()
+
+    @header.setter
+    def header(self, header):
+        self._header = header
+        self._status.modified()
+
+    @property
+    def pollutant(self):
+        return self._pollutant
+
+    @property
+    def type(self):
+        return self._type
+
+    @type.setter
+    def type(self, type):
+        self._type = type
+        self._status.modified()
+
+    @property
+    def data(self):
+        return self._data.copy()
+
+
+
+
+
+
+
+
+
+
+

src/Model/BoundaryConditionsAdisTS/BoundaryConditionsAdisTSList.py

@@ -0,0 +1,68 @@
+# BoundaryConditionsAdisTSList.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+from copy import copy
+from tools import trace, timer
+
+from Model.Tools.PamhyrList import PamhyrModelList
+from Model.Except import NotImplementedMethodeError
+
+from Model.BoundaryConditionsAdisTS.BoundaryConditionAdisTS import BoundaryConditionAdisTS
+
+class BoundaryConditionsAdisTSList(PamhyrModelList):
+    _sub_classes = [
+        BoundaryConditionAdisTS,
+    ]
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = cls(status=data['status'])
+
+        if data is None:
+            data = {}
+
+        new._lst = BoundaryConditionAdisTS._db_load(
+            execute, data
+        )
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        execute("DELETE FROM boundary_condition_adists")
+        execute("DELETE FROM boundary_condition_data_adists")
+
+        if data is None:
+            data = {}
+
+        for bc in self._lst:
+            bc._db_save(execute, data=data)
+
+        return True
+
+    def new(self, index, pollutant):
+        n = BoundaryConditionAdisTS(pollutant=pollutant, status=self._status)
+        self._lst.insert(index, n)
+        self._status.modified()
+        return n
+
+    @property
+    def BCs_AdisTS_List(self):
+        return self.lst
+
+
+

src/Model/D90AdisTS/D90AdisTS.py

@@ -0,0 +1,201 @@
+# D90AdisTS.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import logging
+from functools import reduce
+
+from tools import trace, timer, old_pamhyr_date_to_timestamp
+
+from Model.Tools.PamhyrDB import SQLSubModel
+from Model.Except import NotImplementedMethodeError
+
+from Model.D90AdisTS.D90AdisTSSpec import D90AdisTSSpec
+
+logger = logging.getLogger()
+
+class D90AdisTS(SQLSubModel):
+    _sub_classes = [
+        D90AdisTSSpec,
+    ]
+    _id_cnt = 0
+
+    def __init__(self, id: int = -1, name: str = "default",
+                 status=None):
+        super(D90AdisTS, self).__init__()
+
+        self._status = status
+
+        if id == -1:
+            self.id = D90AdisTS._id_cnt
+        else:
+            self.id = id
+
+        self._name = name
+        self._d90 = None
+        self._enabled = True
+        self._data = []
+
+        D90AdisTS._id_cnt = max(
+            D90AdisTS._id_cnt + 1,
+            self.id
+        )
+
+    @classmethod
+    def _db_create(cls, execute):
+        execute("""
+                  CREATE TABLE d90_adists(
+                    id INTEGER NOT NULL PRIMARY KEY,
+                    name TEXT NOT NULL,
+                    d90 REAL NOT NULL,
+                    enabled BOOLEAN NOT NULL
+                  )
+                """)
+
+        return cls._create_submodel(execute)
+
+    @classmethod
+    def _db_update(cls, execute, version):
+        major, minor, release = version.strip().split(".")
+        if major == minor == "0":
+            if int(release) < 6:
+                cls._db_create(execute)
+
+        return True
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = []
+
+        table = execute(
+            "SELECT id, name, d90, enabled " +
+            "FROM d90_adists"
+        )
+
+        if table is not None:
+            for row in table:
+                d90_id = row[0]
+                name = row[1]
+                d90 = row[2]
+                enabled = (row[3] == 1)
+
+                D90 = cls(
+                    id=d90_id,
+                    name=name,
+                    status=data['status']
+                )
+
+                D90.d90 = d90
+                D90.enabled = enabled
+
+                data['d90_default_id'] = d90_id
+                D90._data = D90AdisTSSpec._db_load(execute, data)
+
+                new.append(D90)
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        execute(f"DELETE FROM d90_adists WHERE id = {self.id}")
+
+        d90 = -1.
+        if self.d90 is not None:
+            d90 = self.d90
+
+        sql = (
+            "INSERT INTO " +
+            "d90_adists(" +
+            "id, name, d90, enabled" +
+            ") " +
+            "VALUES (" +
+            f"{self.id}, '{self._db_format(self._name)}', " +
+            f"{d90}, {self._enabled}" +
+            ")"
+        )
+
+        execute(sql)
+
+        data['d90_default_id'] = self.id
+        execute(
+            "DELETE FROM d90_spec " +
+            f"WHERE d90_default = {self.id}"
+        )
+
+        for d90_spec in self._data:
+            d90_spec._db_save(execute, data)
+
+        return True
+
+    def __len__(self):
+        return len(self._data)
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, name):
+        self._name = name
+        self._status.modified()
+
+    @property
+    def d90(self):
+        return self._d90
+
+    @d90.setter
+    def d90(self, d90):
+        self._d90 = d90
+        self._status.modified()
+
+    @property
+    def enabled(self):
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, enabled):
+        self._enabled = enabled
+        self._status.modified()
+
+    def new(self, index):
+        n = D90AdisTSSpec(status=self._status)
+        self._data.insert(index, n)
+        self._status.modified()
+        return n
+
+    def delete(self, data):
+        self._data = list(
+            filter(
+                lambda x: x not in data,
+                self._data
+            )
+        )
+        self._status.modified()
+
+    def delete_i(self, indexes):
+        for ind in indexes:
+            del self._data[ind]
+        self._status.modified()
+
+    def insert(self, index, data):
+        self._data.insert(index, data)
+        self._status.modified()
+
+
+
+
+
+

src/Model/D90AdisTS/D90AdisTSList.py

@@ -0,0 +1,66 @@
+# D90AdisTSList.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+from copy import copy
+from tools import trace, timer
+
+from Model.Tools.PamhyrList import PamhyrModelList
+from Model.D90AdisTS.D90AdisTS import D90AdisTS
+
+class D90AdisTSList(PamhyrModelList):
+    _sub_classes = [
+        D90AdisTS,
+    ]
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = cls(status=data['status'])
+
+        if data is None:
+            data = {}
+
+        new._lst = D90AdisTS._db_load(
+            execute, data
+        )
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        execute("DELETE FROM d90_adists")
+
+        if data is None:
+            data = {}
+
+        for d90 in self._lst:
+            d90._db_save(execute, data=data)
+
+        return True
+
+    def new(self, index):
+        n = D90AdisTS(status=self._status)
+        self._lst.insert(index, n)
+        self._status.modified()
+        return n
+
+    @property
+    def D90_AdisTS_List(self):
+        return self.lst
+
+
+
+

src/Model/D90AdisTS/D90AdisTSSpec.py

@@ -0,0 +1,200 @@
+# D90AdisTSSpec.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import logging
+
+from tools import trace, timer
+
+from Model.Tools.PamhyrDB import SQLSubModel
+from Model.Except import NotImplementedMethodeError
+
+logger = logging.getLogger()
+
+class D90AdisTSSpec(SQLSubModel):
+    _sub_classes = [
+    ]
+    _id_cnt = 0
+
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None):
+        super(D90AdisTSSpec, self).__init__()
+
+        self._status = status
+
+        if id == -1:
+            self.id = D90AdisTSSpec._id_cnt
+        else:
+            self.id = id
+
+        self._name_section = name
+        self._reach = None
+        self._start_kp = None
+        self._end_kp = None
+        self._d90 = None
+        self._enabled = True
+
+        D90AdisTSSpec._id_cnt = max(D90AdisTSSpec._id_cnt + 1, self.id)
+
+    @classmethod
+    def _db_create(cls, execute):
+        execute("""
+              CREATE TABLE d90_spec(
+                id INTEGER NOT NULL PRIMARY KEY,
+                d90_default INTEGER NOT NULL,
+                name TEXT NOT NULL,
+                reach INTEGER NOT NULL,
+                start_kp REAL NOT NULL,
+                end_kp REAL NOT NULL,
+                d90 REAL NOT NULL,
+                enabled BOOLEAN NOT NULL,
+                FOREIGN KEY(d90_default) REFERENCES d90_adists(id),
+                FOREIGN KEY(reach) REFERENCES river_reach(id)
+              )
+            """)
+
+        return cls._create_submodel(execute)
+
+    @classmethod
+    def _db_update(cls, execute, version):
+        major, minor, release = version.strip().split(".")
+        if major == minor == "0":
+            if int(release) < 6:
+                cls._db_create(execute)
+
+        return True
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = []
+
+        table = execute(
+            "SELECT id, d90_default, name, reach, start_kp, end_kp, " +
+            "d90, enabled " +
+            "FROM d90_spec " +
+            f"WHERE d90_default = {data['d90_default_id']} "
+        )
+
+        for row in table:
+            id            = row[0]
+            name          = row[2]
+            reach         = row[3]
+            start_kp      = row[4]
+            end_kp        = row[5]
+            d90 = row[6]
+            enabled       = (row[7] == 1)
+
+            new_spec = cls(
+                id=id,
+                name=name,
+                status=data['status']
+            )
+
+            new_spec.reach = reach
+            new_spec.start_kp = start_kp
+            new_spec.end_kp = end_kp
+            new_spec.d90 = d90
+            new_spec.enabled = enabled
+
+            new.append(new_spec)
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        d90_default = data['d90_default_id']
+
+        sql = (
+            "INSERT INTO " +
+            "d90_spec(id, d90_default, name, reach, " +
+            "start_kp, end_kp, d90, enabled) " +
+            "VALUES (" +
+            f"{self.id}, " +
+            f"{d90_default}, " +
+            f"'{self._db_format(self._name_section)}', " +
+            f"{self._reach}, " +
+            f"{self._start_kp}, " +
+            f"{self._end_kp}, " +
+            f"{self._d90}, " +
+            f"{self._enabled}" +
+            ")"
+        )
+        execute(sql)
+
+        return True
+
+    @property
+    def name(self):
+        return self._name_section
+
+    @name.setter
+    def name(self, name):
+        self._name_section = name
+        self._status.modified()
+
+    @property
+    def reach(self):
+        return self._reach
+
+    @reach.setter
+    def reach(self, reach):
+        self._reach = reach
+        self._status.modified()
+
+    @property
+    def start_kp(self):
+        return self._start_kp
+
+    @start_kp.setter
+    def start_kp(self, start_kp):
+        self._start_kp = start_kp
+        self._status.modified()
+
+    @property
+    def end_kp(self):
+        return self._end_kp
+
+    @end_kp.setter
+    def end_kp(self, end_kp):
+        self._end_kp = end_kp
+        self._status.modified()
+
+    @property
+    def d90(self):
+        return self._d90
+
+    @d90.setter
+    def d90(self, d90):
+        self._d90 = d90
+        self._status.modified()
+
+    @property
+    def enabled(self):
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, enabled):
+        self._enabled = enabled
+        self._status.modified()
+
+
+
+
+
+
+
+
+

src/Model/DIFAdisTS/DIFAdisTS.py

@@ -0,0 +1,258 @@
+# DIFAdisTS.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import logging
+from functools import reduce
+
+from tools import trace, timer, old_pamhyr_date_to_timestamp
+
+from Model.Tools.PamhyrDB import SQLSubModel
+from Model.Except import NotImplementedMethodeError
+
+from Model.DIFAdisTS.DIFAdisTSSpec import DIFAdisTSSpec
+
+logger = logging.getLogger()
+
+class DIFAdisTS(SQLSubModel):
+    _sub_classes = [
+        DIFAdisTSSpec,
+    ]
+    _id_cnt = 0
+
+    def __init__(self, id: int = -1, name: str = "default",
+                 status=None):
+        super(DIFAdisTS, self).__init__()
+
+        self._status = status
+
+        if id == -1:
+            self.id = DIFAdisTS._id_cnt
+        else:
+            self.id = id
+
+        self._name = name
+        self._method = None
+        self._dif = None
+        self._b = None
+        self._c = None
+        self._enabled = True
+        self._types = ["iwasa", "fisher", "elder", "constante", "generique"]
+        self._data = []
+
+        DIFAdisTS._id_cnt = max(
+            DIFAdisTS._id_cnt + 1,
+            self.id
+        )
+
+    @classmethod
+    def _db_create(cls, execute):
+        execute("""
+                  CREATE TABLE dif_adists(
+                    id INTEGER NOT NULL PRIMARY KEY,
+                    name TEXT NOT NULL,
+                    method TEXT NOT NULL,
+                    dif REAL NOT NULL,
+                    b REAL,
+                    c REAL,
+                    enabled BOOLEAN NOT NULL
+                  )
+                """)
+
+        return cls._create_submodel(execute)
+
+    @classmethod
+    def _db_update(cls, execute, version):
+        major, minor, release = version.strip().split(".")
+        if major == minor == "0":
+            if int(release) < 6:
+                cls._db_create(execute)
+
+        return True
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = []
+
+        table = execute(
+            "SELECT id, name, method, dif, b, c, enabled " +
+            "FROM dif_adists"
+        )
+
+        if table is not None:
+            for row in table:
+                dif_id = row[0]
+                name = row[1]
+                method = row[2]
+                dif = row[3]
+                b = row[4]
+                c = row[5]
+                enabled = (row[6] == 1)
+
+                DIF = cls(
+                    id=dif_id,
+                    name=name,
+                    status=data['status']
+                )
+
+                DIF.method = method
+                DIF.dif = dif
+                DIF.b = b
+                DIF.c = c
+                DIF.enabled = enabled
+
+                data['dif_default_id'] = dif_id
+                DIF._data = DIFAdisTSSpec._db_load(execute, data)
+
+                new.append(DIF)
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        execute(f"DELETE FROM dif_adists WHERE id = {self.id}")
+
+        method = ""
+        if self.method is not None:
+            method = self.method
+
+        dif = -1.
+        if self.dif is not None:
+            dif = self.dif
+
+        b = -1.
+        if self.b is not None:
+            b = self.b
+
+        c = -1.
+        if self.dif is not None:
+            c = self.c
+
+        sql = (
+            "INSERT INTO " +
+            "dif_adists(" +
+            "id, name, method, dif, b, c, enabled" +
+            ") " +
+            "VALUES (" +
+            f"{self.id}, '{self._db_format(self._name)}', " +
+            f"'{self._db_format(self._method)}', " +
+            f"{dif}, {b}, {c}, {self._enabled}" +
+            ")"
+        )
+
+        execute(sql)
+
+        data['dif_default_id'] = self.id
+        execute(
+            "DELETE FROM dif_spec " +
+            f"WHERE dif_default = {self.id}"
+        )
+
+        for dif_spec in self._data:
+            dif_spec._db_save(execute, data)
+
+        return True
+
+    def __len__(self):
+        return len(self._data)
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, name):
+        self._name = name
+        self._status.modified()
+
+    @property
+    def method(self):
+        return self._method
+
+    @method.setter
+    def method(self, method):
+        self._method = method
+        self._status.modified()
+
+    @property
+    def types(self):
+        return self._types
+
+    @property
+    def dif(self):
+        return self._dif
+
+    @dif.setter
+    def dif(self, dif):
+        self._dif = dif
+        self._status.modified()
+
+    @property
+    def b(self):
+        return self._b
+
+    @b.setter
+    def b(self, b):
+        self._b = b
+        self._status.modified()
+
+    @property
+    def c(self):
+        return self._c
+
+    @c.setter
+    def c(self, c):
+        self._c = c
+        self._status.modified()
+
+    @property
+    def enabled(self):
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, enabled):
+        self._enabled = enabled
+        self._status.modified()
+
+    def new(self, index):
+        n = DIFAdisTSSpec(status=self._status)
+        self._data.insert(index, n)
+        self._status.modified()
+        return n
+
+    def delete(self, data):
+        self._data = list(
+            filter(
+                lambda x: x not in data,
+                self._data
+            )
+        )
+        self._status.modified()
+
+    def delete_i(self, indexes):
+        for ind in indexes:
+            del self._data[ind]
+        self._status.modified()
+
+    def insert(self, index, data):
+        self._data.insert(index, data)
+        self._status.modified()
+
+
+
+
+
+

src/Model/DIFAdisTS/DIFAdisTSList.py

@@ -0,0 +1,66 @@
+# DIFAdisTSList.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+from copy import copy
+from tools import trace, timer
+
+from Model.Tools.PamhyrList import PamhyrModelList
+from Model.DIFAdisTS.DIFAdisTS import DIFAdisTS
+
+class DIFAdisTSList(PamhyrModelList):
+    _sub_classes = [
+        DIFAdisTS,
+    ]
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = cls(status=data['status'])
+
+        if data is None:
+            data = {}
+
+        new._lst = DIFAdisTS._db_load(
+            execute, data
+        )
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        execute("DELETE FROM dif_adists")
+
+        if data is None:
+            data = {}
+
+        for dif in self._lst:
+            dif._db_save(execute, data=data)
+
+        return True
+
+    def new(self, index):
+        n = DIFAdisTS(status=self._status)
+        self._lst.insert(index, n)
+        self._status.modified()
+        return n
+
+    @property
+    def DIF_AdisTS_List(self):
+        return self.lst
+
+
+
+

src/Model/DIFAdisTS/DIFAdisTSSpec.py

@@ -0,0 +1,228 @@
+# DIFAdisTSSpec.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import logging
+
+from tools import trace, timer
+
+from Model.Tools.PamhyrDB import SQLSubModel
+from Model.Except import NotImplementedMethodeError
+
+logger = logging.getLogger()
+
+class DIFAdisTSSpec(SQLSubModel):
+    _sub_classes = [
+    ]
+    _id_cnt = 0
+
+    def __init__(self, id: int = -1, method: str = "",
+                 status=None):
+        super(DIFAdisTSSpec, self).__init__()
+
+        self._status = status
+
+        if id == -1:
+            self.id = DIFAdisTSSpec._id_cnt
+        else:
+            self.id = id
+
+        self._method = method
+        self._reach = None
+        self._start_kp = None
+        self._end_kp = None
+        self._dif = None
+        self._b = None
+        self._c = None
+        self._enabled = True
+
+        DIFAdisTSSpec._id_cnt = max(DIFAdisTSSpec._id_cnt + 1, self.id)
+
+    @classmethod
+    def _db_create(cls, execute):
+        execute("""
+              CREATE TABLE dif_spec(
+                id INTEGER NOT NULL PRIMARY KEY,
+                dif_default INTEGER NOT NULL,
+                method TEXT NOT NULL,
+                reach INTEGER NOT NULL,
+                start_kp REAL NOT NULL,
+                end_kp REAL NOT NULL,
+                dif REAL NOT NULL,
+                b REAL,
+                c REAL,
+                enabled BOOLEAN NOT NULL,
+                FOREIGN KEY(dif_default) REFERENCES dif_adists(id),
+                FOREIGN KEY(reach) REFERENCES river_reach(id)
+              )
+            """)
+
+        return cls._create_submodel(execute)
+
+    @classmethod
+    def _db_update(cls, execute, version):
+        major, minor, release = version.strip().split(".")
+        if major == minor == "0":
+            if int(release) < 6:
+                cls._db_create(execute)
+
+        return True
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = []
+
+        table = execute(
+            "SELECT id, dif_default, method, reach, start_kp, end_kp, " +
+            "dif, b, c, enabled " +
+            "FROM dif_spec " +
+            f"WHERE dif_default = {data['dif_default_id']} "
+        )
+
+        for row in table:
+            id            = row[0]
+            method          = row[2]
+            reach         = row[3]
+            start_kp      = row[4]
+            end_kp        = row[5]
+            dif = row[6]
+            b = row[7]
+            c = row[8]
+            enabled       = (row[9] == 1)
+
+            new_spec = cls(
+                id=id,
+                method=method,
+                status=data['status']
+            )
+
+            new_spec.reach = reach
+            new_spec.start_kp = start_kp
+            new_spec.end_kp = end_kp
+            new_spec.dif = dif
+            new_spec.b = b
+            new_spec.c = c
+            new_spec.enabled = enabled
+
+            new.append(new_spec)
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        dif_default = data['dif_default_id']
+
+        sql = (
+            "INSERT INTO " +
+            "dif_spec(id, dif_default, method, reach, " +
+            "start_kp, end_kp, dif, b, c, enabled) " +
+            "VALUES (" +
+            f"{self.id}, " +
+            f"{dif_default}, " +
+            f"'{self._db_format(self._method)}', " +
+            f"{self._reach}, " +
+            f"{self._start_kp}, " +
+            f"{self._end_kp}, " +
+            f"{self._dif}, " +
+            f"{self._b}, " +
+            f"{self._c}, " +
+            f"{self._enabled}" +
+            ")"
+        )
+        execute(sql)
+
+        return True
+
+    @property
+    def method(self):
+        return self._method
+
+    @method.setter
+    def method(self, method):
+        self._method = method
+        self._status.modified()
+
+    @property
+    def reach(self):
+        return self._reach
+
+    @reach.setter
+    def reach(self, reach):
+        self._reach = reach
+        self._status.modified()
+
+    @property
+    def start_kp(self):
+        return self._start_kp
+
+    @start_kp.setter
+    def start_kp(self, start_kp):
+        self._start_kp = start_kp
+        self._status.modified()
+
+    @property
+    def end_kp(self):
+        return self._end_kp
+
+    @end_kp.setter
+    def end_kp(self, end_kp):
+        self._end_kp = end_kp
+        self._status.modified()
+
+    @property
+    def dif(self):
+        return self._dif
+
+    @dif.setter
+    def dif(self, dif):
+        self._dif = dif
+        self._status.modified()
+
+    @property
+    def b(self):
+        return self._b
+
+    @b.setter
+    def b(self, b):
+        self._b = b
+        self._status.modified()
+
+    @property
+    def c(self):
+        return self._c
+
+    @c.setter
+    def c(self, c):
+        self._c = c
+        self._status.modified()
+
+    @property
+    def enabled(self):
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, enabled):
+        self._enabled = enabled
+        self._status.modified()
+
+
+
+
+
+
+
+
+

src/Model/Except.py

@@ -21,7 +21,7 @@ from PyQt5.QtCore import (
 )
 
 from PyQt5.QtWidgets import (
-    QApplication, QMessageBox,
+    QApplication, QMessageBox, QLabel,
 )
 
 _translate = QCoreApplication.translate
@@ -34,6 +34,7 @@ _translate = QCoreApplication.translate
 def exception_message_box(exception):
     msg = QMessageBox()
     msg.setIcon(QMessageBox.Critical)
+    msg.findChild(QLabel, "qt_msgbox_label").setFixedWidth(384)
 
     msg.setText("Exception :")
     msg.setInformativeText(f"{exception}")

src/Model/Friction/Friction.py

@@ -209,6 +209,14 @@ class Friction(SQLSubModel):
 
         self._status.modified()
 
+    def __contains__(self, kp):
+        return self.contains_kp(kp)
+
+    def contains_kp(self, kp):
+        return (
+            self._begin_kp <= kp <= self._end_kp
+        )
+
     @property
     def begin_strickler(self):
         return self._begin_strickler

src/Model/Geometry/PointXYZ.py

@@ -192,6 +192,22 @@ class PointXYZ(Point, SQLSubModel):
     def dist(self, p2):
         return PointXYZ.distance(self, p2)
 
+    def dist_2d(self, p2):
+        return PointXYZ.distance_2d(self, p2)
+
+    @staticmethod
+    def distance_2d(p1, p2):
+        """Euclidean distance between p1 and p2.
+
+        Args:
+            p1: A XYZ Point
+            p2: A XYZ Point
+
+        Returns:
+            Euclidean 2D distance between the two points
+        """
+        return dist((p1.x, p1.y), (p2.x, p2.y))
+
     @staticmethod
     def distance(p1, p2):
         """Euclidean distance between p1 and p2.
@@ -201,6 +217,14 @@ class PointXYZ(Point, SQLSubModel):
             p2: A XYZ Point
 
         Returns:
-            Euclidean distance between the two points
+            Euclidean 3D distance between the two points
         """
         return dist((p1.x, p1.y, p1.z), (p2.x, p2.y, p2.z))
+
+    @staticmethod
+    def areatriangle3d(p1, p2, p3):
+        a = PointXYZ.distance(p1, p2)
+        b = PointXYZ.distance(p2, p3)
+        c = PointXYZ.distance(p3, p1)
+        s = (a + b + c) / 2
+        return (s*(s-a) * (s-b)*(s-c)) ** 0.5

src/Model/Geometry/Profile.py

@@ -19,6 +19,7 @@
 import logging
 
 from tools import timer
+from shapely import geometry
 
 from Model.Geometry.Point import Point
 from Model.Except import NotImplementedMethodeError
@@ -295,6 +296,11 @@ class Profile(object):
         )
         self._status.modified()
 
+    @timer
+    def reverse(self):
+        self._points.reverse()
+        self._status.modified()
+
     # Sediment Layers
 
     def get_sl(self):
@@ -341,3 +347,12 @@ class Profile(object):
     # Abstract method for width approximation
     def get_water_limits(self, z):
         raise NotImplementedMethodeError(self, self.get_water_limits)
+
+    def wet_points(self, z):
+        raise NotImplementedMethodeError(self, self.wet_point)
+
+    def wet_perimeter(self, z):
+        raise NotImplementedMethodeError(self, self.wet_perimeter)
+
+    def wet_area(self, z):
+        raise NotImplementedMethodeError(self, self.wet_area)

src/Model/Geometry/ProfileXYZ.py

@@ -22,6 +22,7 @@ from typing import List
 from functools import reduce
 
 from tools import timer
+from shapely import geometry
 
 from Model.Tools.PamhyrDB import SQLSubModel
 from Model.Except import ClipboardFormatError
@@ -373,99 +374,13 @@ class ProfileXYZ(Profile, SQLSubModel):
         """
         return [x for x in lst if not np.isnan(x)]
 
-    def _first_point_not_nan(self):
-        first_point = self.points[0]
+    def speed(self, q, z):
+        area = self.wet_area(z)
 
-        for point in self.points:
-            if not point.is_nan():
-                first_point = point
-                break
+        if area == 0:
+            return 0
 
-        return first_point
-
-    def _last_point_not_nan(self):
-        last_point = self.points[-1]
-
-        for point in self.points[::-1]:
-            if not point.is_nan():
-                last_point = point
-                break
-
-        return last_point
-
-    @timer
-    def get_station(self) -> np.ndarray:
-        """Projection of the points of the profile on a plane.
-
-        Args:
-            profile: The profile
-
-        Returns:
-            Projection of the points of the profile on a plane.
-        """
-        if self.nb_points < 3:
-            return None
-        else:
-            first_named_point = None
-            index_first_named_point = None
-            last_named_point = None
-
-            first_point_not_nan = self._first_point_not_nan()
-            last_point_not_nan = self._last_point_not_nan()
-
-            for index, point in enumerate(self.points):
-                if point.point_is_named():
-                    index_first_named_point = index
-                    first_named_point = point
-                    break
-
-            for point in reversed(self.points):
-                if point.point_is_named():
-                    last_named_point = point
-                    break
-
-            station = []
-            constant = 0.0
-
-            if (first_named_point is not None and
-                    last_named_point is not None):
-                if (first_named_point != last_named_point and
-                        first_named_point.x != last_named_point.x):
-                    vector = Vector1d(first_named_point, last_named_point)
-                    norm_dir_vec = vector.normalized_direction_vector()
-                else:
-                    vector = Vector1d(first_point_not_nan, last_point_not_nan)
-                    norm_dir_vec = vector.normalized_direction_vector()
-
-                for point in self.points:
-                    xi = point.x - first_named_point.x
-                    yi = point.y - first_named_point.y
-                    station_i = (norm_dir_vec[0] * xi +
-                                 norm_dir_vec[1] * yi)
-                    station.append(station_i)
-
-                constant = station[index_first_named_point]
-            elif first_named_point is None:
-                vector = Vector1d(first_point_not_nan, last_point_not_nan)
-                norm_dir_vec = vector.normalized_direction_vector()
-
-                for point in self.points:
-                    xi = point.x - first_point_not_nan.x
-                    yi = point.y - first_point_not_nan.y
-                    station_i = (norm_dir_vec[0] * xi +
-                                 norm_dir_vec[1] * yi)
-                    station.append(station_i)
-
-                z_min = self.z_min()
-                index_profile_z_min = list(
-                    filter(
-                        lambda z: z[1] == z_min,
-                        enumerate(self.z())
-                    )
-                )[0]
-                constant = station[index_profile_z_min[0]]
-
-            return list(map(lambda s: s - constant, station))
+        return q / area
 
     def width_approximation(self):
         if self.has_standard_named_points():
@@ -477,6 +392,42 @@ class ProfileXYZ(Profile, SQLSubModel):
 
         return abs(rg.dist(rd))
 
+    def wet_perimeter(self, z):
+        poly = self.wet_polygon(z)
+
+        if poly is None:
+            return 0
+
+        return poly.length
+
+    def wet_area(self, z):
+        poly = self.wet_polygon(z)
+
+        if poly is None:
+            return 0
+
+        return poly.area
+
+    def wet_polygon(self, z):
+        points = self.wet_points(z)
+        if len(points) < 3:
+            return None
+
+        z = map(lambda p: p.z, points)
+        station = self._get_station(points)
+
+        poly = geometry.Polygon(list(zip(station, z)))
+        return poly
+
+    def wet_points(self, z):
+        left, right = self.get_water_limits(z)
+
+        points = list(filter(lambda p: p.z < z, self._points))
+        points = [left] + points + [right]
+        points = sorted(points, key=lambda p: p.x)
+
+        return points
+
     def get_water_limits(self, z):
         """
         Determine left and right limits of water elevation.
@@ -509,7 +460,7 @@ class ProfileXYZ(Profile, SQLSubModel):
                 [self.point(i_left).z, self.point(i_left - 1).z],
                 [self.point(i_left).y, self.point(i_left - 1).y]
             )
-            pt_left = PointXYZ(x, y, z)
+            pt_left = PointXYZ(x, y, z, name="wl_left")
         else:
             pt_left = self.point(0)
 
@@ -525,8 +476,151 @@ class ProfileXYZ(Profile, SQLSubModel):
                 [self.point(i_right).z, self.point(i_right + 1).z],
                 [self.point(i_right).y, self.point(i_right + 1).y]
             )
-            pt_right = PointXYZ(x, y, z)
+            pt_right = PointXYZ(x, y, z, name="wl_right")
         else:
             pt_right = self.point(self.number_points - 1)
 
         return pt_left, pt_right
+
+    def get_station(self):
+        """Projection of the points of the profile on a plane.
+
+        Args:
+            self: The profile
+
+        Returns:
+            Projection of the points of the profile on a plane.
+        """
+        if self.nb_points < 3:
+            return None
+        else:
+            return self._get_station(self.points)
+
+    @timer
+    def _get_station(self, points):
+        first_named_point = None
+        index_first_named_point = None
+        last_named_point = None
+
+        first_point_not_nan = self._first_point_not_nan(points)
+        last_point_not_nan = self._last_point_not_nan(points)
+
+        for index, point in enumerate(points):
+            if point.point_is_named():
+                index_first_named_point = index
+                first_named_point = point
+                break
+
+        for point in reversed(points):
+            if point.point_is_named():
+                last_named_point = point
+                break
+
+        station = []
+        constant = 0.0
+
+        if (first_named_point is not None
+                and last_named_point is not None):
+            if (first_named_point != last_named_point
+                    and first_named_point.x != last_named_point.x):
+                vector = Vector1d(first_named_point, last_named_point)
+                norm_dir_vec = vector.normalized_direction_vector()
+            else:
+                vector = Vector1d(first_point_not_nan, last_point_not_nan)
+                norm_dir_vec = vector.normalized_direction_vector()
+
+            for point in points:
+                xi = point.x - first_named_point.x
+                yi = point.y - first_named_point.y
+                station_i = (norm_dir_vec[0] * xi +
+                             norm_dir_vec[1] * yi)
+                station.append(station_i)
+
+            constant = station[index_first_named_point]
+        elif first_named_point is None:
+            vector = Vector1d(first_point_not_nan, last_point_not_nan)
+            norm_dir_vec = vector.normalized_direction_vector()
+
+            for point in points:
+                xi = point.x - first_point_not_nan.x
+                yi = point.y - first_point_not_nan.y
+                station_i = (norm_dir_vec[0] * xi +
+                             norm_dir_vec[1] * yi)
+                station.append(station_i)
+
+            z_min = self.z_min()
+            index_profile_z_min = next(
+                filter(
+                    lambda z: z[1] == z_min,
+                    enumerate(self.z())
+                )
+            )
+            constant = station[index_profile_z_min[0]]
+
+        return list(map(lambda s: s - constant, station))
+
+    def _first_point_not_nan(self, points):
+        first_point = None
+
+        for point in points:
+            if not point.is_nan():
+                first_point = point
+                break
+
+        return first_point
+
+    def _last_point_not_nan(self, points):
+        last_point = None
+
+        for point in reversed(points):
+            if not point.is_nan():
+                last_point = point
+                break
+
+        return last_point
+
+    def purge(self, np_purge):
+        """
+        Remove points to keep at most np_purge points.
+        """
+        if (self.nb_points <= np_purge):
+            return
+
+        nb_named = 2   # we consider the first and last point as named
+        area = [0.0]
+
+        for i in range(1, self.nb_points-1):
+            if self.point(i).point_is_named():
+                area.append(9999999.999)
+                nb_named += 1
+            else:
+                area.append(
+                    PointXYZ.areatriangle3d(
+                        self.point(i-1),
+                        self.point(i),
+                        self.point(i+1))
+                )
+
+        area.append(0.0)
+
+        while self.nb_points > max(np_purge, nb_named):
+            to_rm = np.argmin(area[1:self.nb_points - 1]) + 1
+
+            self.delete_i([to_rm])
+            area.pop(to_rm)
+
+            for i in [to_rm-1, to_rm]:
+                if (i == 0):
+                    continue
+
+                if (i == self.nb_points - 1):
+                    continue
+
+                if self.point(i).point_is_named():
+                    area[i] = 9999999.999
+                else:
+                    area[i] = PointXYZ.areatriangle3d(
+                        self.point(i-1),
+                        self.point(i),
+                        self.point(i+1)
+                    )

src/Model/Geometry/Reach.py

@@ -16,7 +16,9 @@
 
 # -*- coding: utf-8 -*-
 
+import os
 import logging
+import shapefile
 import numpy as np
 
 from time import time
@@ -364,6 +366,30 @@ class Reach(SQLSubModel):
         else:
             return 0.0
 
+    def inter_profiles_kp(self):
+        profiles = sorted(self.profiles, key=lambda p: p.kp)
+        first = profiles[0]
+        last = profiles[-1]
+
+        res_kp = [first.kp]
+
+        profiles = iter(profiles)
+        previous = next(profiles)
+
+        for profile in profiles:
+            prev = previous.kp
+            curr = profile.kp
+
+            diff = abs(previous.kp - profile.kp)
+
+            new = previous.kp + (diff / 2.0)
+            res_kp.append(new)
+
+            previous = profile
+
+        res_kp.append(last.kp)
+        return res_kp
+
     # Sediment Layers
 
     def get_sl(self):
@@ -533,8 +559,66 @@ class Reach(SQLSubModel):
 
     # Import/Export
 
-    @timer
     def import_geometry(self, file_path_name: str):
+        ext = file_path_name.split(".")
+        if len(ext) > 0:
+            ext = ext[-1].lower()
+
+            if ext in ['st', 'm']:
+                return self.import_geometry_st(file_path_name)
+
+            if ext in ['shp']:
+                return self.import_geometry_shp(file_path_name)
+
+        raise FileFormatError(
+            file_path_name,
+            f"Geometry file extention ('.{ext}') unkown"
+        )
+
+    @timer
+    def import_geometry_shp(self, file_path_name: str):
+        sf = shapefile.Reader(
+            os.path.abspath(file_path_name)
+        )
+
+        if sf.shapeType != shapefile.POLYLINEZ:
+            raise FileFormatError(
+                file_path_name,
+                "Shapefile is not a POLYLINEZ"
+            )
+
+        profiles = []
+
+        for i in range(len(sf)):
+            s_profile = sf.shape(i)
+            z = s_profile.z
+
+            ind = 0
+            points = []
+            for point in s_profile.points:
+                points.append([
+                    point[0],
+                    point[1],
+                    z[ind]
+                ])
+
+                ind += 1
+
+            prof = ProfileXYZ(
+                reach=self, status=self._status
+            )
+            prof.import_points(points)
+
+            profiles.append(prof)
+
+        self.profiles = profiles + self.profiles
+        self._update_profile_numbers()
+        self._recompute_kp()
+
+        return profiles
+
+    @timer
+    def import_geometry_st(self, file_path_name: str):
         """Import a geometry from file (.ST or .st)
 
         Args:
@@ -762,3 +846,24 @@ class Reach(SQLSubModel):
         except Exception as e:
             logger_exception(e)
             return 0
+
+    def _recompute_kp(self, offset=0.0):
+        self._recompute_kp_no_gl(offset=offset)
+
+    def _recompute_kp_no_gl(self, offset=0.0):
+        profiles = iter(self.profiles)
+
+        previous = next(profiles)
+        previous.kp = offset
+
+        for profile in profiles:
+            prev_points = previous.points
+            curr_points = profile.points
+
+            dist = (
+                prev_points[0].dist_2d(curr_points[0]) +
+                prev_points[-1].dist_2d(curr_points[-1])
+            ) / 2.0
+
+            profile.kp = previous.kp + dist
+            previous = profile

src/Model/HydraulicStructures/HydraulicStructures.py

@@ -64,6 +64,7 @@ class HydraulicStructure(SQLSubModel):
 
     @classmethod
     def _db_create(cls, execute):
+
         execute("""
           CREATE TABLE hydraulic_structures(
             id INTEGER NOT NULL PRIMARY KEY,
@@ -138,6 +139,7 @@ class HydraulicStructure(SQLSubModel):
         return new
 
     def _db_save(self, execute, data=None):
+        print("save hs unit")
         execute(f"DELETE FROM hydraulic_structures WHERE id = {self.id}")
 
         input_reach_id = -1

src/Model/InitialConditions/InitialConditions.py

@@ -266,6 +266,9 @@ class InitialConditions(SQLSubModel):
     def __len__(self):
         return len(self._data)
 
+    def lst(self):
+        return self._data
+
     @property
     def reach(self):
         return self._reach
@@ -295,6 +298,15 @@ class InitialConditions(SQLSubModel):
         self._data.insert(index, n)
         self._status.modified()
 
+    def new_from_data(self, kp, discharge, elevation):
+        n = Data(reach=self._reach, status=self._status)
+
+        n['kp'] = kp
+        n['discharge'] = discharge
+        n['elevation'] = elevation
+
+        return n
+
     def insert(self, index, data):
         self._data.insert(index, data)
         self._status.modified()

src/Model/InitialConditionsAdisTS/InitialConditionsAdisTS.py

@@ -0,0 +1,272 @@
+# InitialConditionsAdisTS.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import logging
+from functools import reduce
+
+from tools import trace, timer, old_pamhyr_date_to_timestamp
+
+from Model.Tools.PamhyrDB import SQLSubModel
+from Model.Except import NotImplementedMethodeError
+
+from Model.InitialConditionsAdisTS.InitialConditionsAdisTSSpec import ICAdisTSSpec
+
+logger = logging.getLogger()
+
+class InitialConditionsAdisTS(SQLSubModel):
+    _sub_classes = [
+        ICAdisTSSpec,
+    ]
+    _id_cnt = 0
+
+    def __init__(self, id: int = -1, name: str = "default",
+                 pollutant: int = -1, status=None):
+        super(InitialConditionsAdisTS, self).__init__()
+
+        self._status = status
+
+        if id == -1:
+            self.id = InitialConditionsAdisTS._id_cnt
+        else:
+            self.id = id
+
+        self._name = name
+        self._pollutant = pollutant
+        self._concentration = None
+        self._eg = None
+        self._em = None
+        self._ed = None
+        self._enabled = True
+        self._data = []
+
+        InitialConditionsAdisTS._id_cnt = max(
+            InitialConditionsAdisTS._id_cnt + 1,
+            self.id
+        )
+
+    @classmethod
+    def _db_create(cls, execute):
+        execute("""
+                  CREATE TABLE initial_conditions_adists(
+                    id INTEGER NOT NULL PRIMARY KEY,
+                    pollutant INTEGER NOT NULL,
+                    name TEXT NOT NULL,
+                    concentration REAL NOT NULL,
+                    eg REAL NOT NULL,
+                    em REAL NOT NULL,
+                    ed REAL NOT NULL,
+                    enabled BOOLEAN NOT NULL,
+                    FOREIGN KEY(pollutant) REFERENCES Pollutants(id)
+                  )
+                """)
+
+        return cls._create_submodel(execute)
+
+    @classmethod
+    def _db_update(cls, execute, version):
+        major, minor, release = version.strip().split(".")
+        if major == minor == "0":
+            if int(release) < 6:
+                cls._db_create(execute)
+
+        return True
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = []
+
+        table = execute(
+            "SELECT id, pollutant, name, concentration, eg, em, ed, " +
+            "enabled " +
+            "FROM initial_conditions_adists"
+        )
+
+        if table is not None:
+            for row in table:
+                IC_id = row[0]
+                pollutant = row[1]
+                name = row[2]
+                concentration = row[3]
+                eg = row[4]
+                em = row[5]
+                ed = row[6]
+                enabled = (row[7] == 1)
+
+                IC = cls(
+                    id=IC_id,
+                    name=name,
+                    status=data['status']
+                )
+
+                IC.pollutant = pollutant
+                IC.concentration = concentration
+                IC.eg = eg
+                IC.em = em
+                IC.ed = ed
+                IC.enabled = enabled
+
+                data['ic_default_id'] = IC_id
+                IC._data = ICAdisTSSpec._db_load(execute, data)
+
+                new.append(IC)
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        execute(f"DELETE FROM initial_conditions_adists WHERE id = {self.id}")
+
+        pollutant = -1
+        if self.pollutant is not None:
+            pollutant = self.pollutant
+
+        concentration = -1.
+        if self.concentration is not None:
+            concentration = self.concentration
+
+        eg = -1.
+        if self.eg is not None:
+            eg = self.eg
+
+        em = -1.
+        if self.em is not None:
+            em = self.em
+
+        ed = -1.
+        if self.ed is not None:
+            ed = self.ed
+
+        sql = (
+            "INSERT INTO " +
+            "initial_conditions_adists(" +
+            "id, pollutant, name, concentration, " +
+            "eg, em, ed, enabled" +
+            ") " +
+            "VALUES (" +
+            f"{self.id}, {pollutant}, '{self._db_format(self._name)}', " +
+            f"{concentration}, {eg}, {em}, {ed}, {self._enabled}" +
+            ")"
+        )
+
+        execute(sql)
+
+        data['ic_default_id'] = self.id
+        execute(
+            "DELETE FROM initial_conditions_spec " +
+            f"WHERE ic_default = {self.id}"
+        )
+
+        for ic_spec in self._data:
+            ic_spec._db_save(execute, data)
+
+        return True
+
+    def __len__(self):
+        return len(self._data)
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, name):
+        self._name = name
+        self._status.modified()
+
+    @property
+    def pollutant(self):
+        return self._pollutant
+
+    @pollutant.setter
+    def pollutant(self, pollutant):
+        self._pollutant = pollutant
+        self._status.modified()
+
+    @property
+    def concentration(self):
+        return self._concentration
+
+    @concentration.setter
+    def concentration(self, concentration):
+        self._concentration = concentration
+        self._status.modified()
+
+    @property
+    def eg(self):
+        return self._eg
+
+    @eg.setter
+    def eg(self, eg):
+        self._eg = eg
+        self._status.modified()
+
+    @property
+    def em(self):
+        return self._em
+
+    @em.setter
+    def em(self, em):
+        self._em = em
+        self._status.modified()
+
+    @property
+    def ed(self):
+        return self._ed
+
+    @ed.setter
+    def ed(self, ed):
+        self._ed = ed
+        self._status.modified()
+
+    @property
+    def enabled(self):
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, enabled):
+        self._enabled = enabled
+        self._status.modified()
+
+    def new(self, index):
+        n = ICAdisTSSpec(status=self._status)
+        self._data.insert(index, n)
+        self._status.modified()
+        return n
+
+    def delete(self, data):
+        self._data = list(
+            filter(
+                lambda x: x not in data,
+                self._data
+            )
+        )
+        self._status.modified()
+
+    def delete_i(self, indexes):
+        for ind in indexes:
+            del self._data[ind]
+        self._status.modified()
+
+    def insert(self, index, data):
+        self._data.insert(index, data)
+        self._status.modified()
+
+
+
+
+
+

src/Model/InitialConditionsAdisTS/InitialConditionsAdisTSList.py

@@ -0,0 +1,66 @@
+# InitialConditionsAdisTSList.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+from copy import copy
+from tools import trace, timer
+
+from Model.Tools.PamhyrList import PamhyrModelList
+from Model.InitialConditionsAdisTS.InitialConditionsAdisTS import InitialConditionsAdisTS
+
+class InitialConditionsAdisTSList(PamhyrModelList):
+    _sub_classes = [
+        InitialConditionsAdisTS,
+    ]
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = cls(status=data['status'])
+
+        if data is None:
+            data = {}
+
+        new._lst = InitialConditionsAdisTS._db_load(
+            execute, data
+        )
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        execute("DELETE FROM initial_conditions_adists")
+
+        if data is None:
+            data = {}
+
+        for ic in self._lst:
+            ic._db_save(execute, data=data)
+
+        return True
+
+    def new(self, index, pollutant):
+        n = InitialConditionsAdisTS(pollutant=pollutant, status=self._status)
+        self._lst.insert(index, n)
+        self._status.modified()
+        return n
+
+    @property
+    def Initial_Conditions_List(self):
+        return self.lst
+
+
+
+

src/Model/InitialConditionsAdisTS/InitialConditionsAdisTSSpec.py

@@ -0,0 +1,258 @@
+# InitialConditionsAdisTSSpec.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import logging
+
+from tools import trace, timer
+
+from Model.Tools.PamhyrDB import SQLSubModel
+from Model.Except import NotImplementedMethodeError
+
+logger = logging.getLogger()
+
+class ICAdisTSSpec(SQLSubModel):
+    _sub_classes = [
+    ]
+    _id_cnt = 0
+
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None):
+        super(ICAdisTSSpec, self).__init__()
+
+        self._status = status
+
+        if id == -1:
+            self.id = ICAdisTSSpec._id_cnt
+        else:
+            self.id = id
+
+        self._name_section = name
+        self._reach = None
+        self._start_kp = None
+        self._end_kp = None
+        self._concentration = None
+        self._eg = None
+        self._em = None
+        self._ed = None
+        self._rate = None
+        self._enabled = True
+
+        ICAdisTSSpec._id_cnt = max(ICAdisTSSpec._id_cnt + 1, self.id)
+
+    @classmethod
+    def _db_create(cls, execute):
+        execute("""
+              CREATE TABLE initial_conditions_spec(
+                id INTEGER NOT NULL PRIMARY KEY,
+                ic_default INTEGER NOT NULL,
+                name TEXT NOT NULL,
+                reach INTEGER NOT NULL,
+                start_kp REAL NOT NULL,
+                end_kp REAL NOT NULL,
+                concentration REAL NOT NULL,
+                eg REAL NOT NULL,
+                em REAL NOT NULL,
+                ed REAL NOT NULL,
+                rate REAL NOT NULL,
+                enabled BOOLEAN NOT NULL,
+                FOREIGN KEY(ic_default) REFERENCES initial_conditions_adists(id),
+                FOREIGN KEY(reach) REFERENCES river_reach(id)
+              )
+            """)
+
+        return cls._create_submodel(execute)
+
+    @classmethod
+    def _db_update(cls, execute, version):
+        major, minor, release = version.strip().split(".")
+        if major == minor == "0":
+            if int(release) < 6:
+                cls._db_create(execute)
+
+        return True
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = []
+
+        table = execute(
+            "SELECT id, ic_default, name, reach, start_kp, end_kp, " +
+            "concentration, eg, em, ed, rate, enabled " +
+            "FROM initial_conditions_spec " +
+            f"WHERE ic_default = {data['ic_default_id']} "
+        )
+
+        for row in table:
+            id            = row[0]
+            name          = row[2]
+            reach         = row[3]
+            start_kp      = row[4]
+            end_kp        = row[5]
+            concentration = row[6]
+            eg            = row[7]
+            em            = row[8]
+            ed            = row[9]
+            rate          = row[10]
+            enabled       = (row[11] == 1)
+
+            #new_spec = [name, reach, start_kp, end_kp, concentration, eg, em, ed, rate, enabled]
+
+            new_spec = cls(
+                id=id,
+                name=name,
+                status=data['status']
+            )
+
+            new_spec.reach = reach
+            new_spec.start_kp = start_kp
+            new_spec.end_kp = end_kp
+            new_spec.concentration = concentration
+            new_spec.eg = eg
+            new_spec.em = em
+            new_spec.ed = ed
+            new_spec.rate = rate
+            new_spec.enabled = enabled
+
+            new.append(new_spec)
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        ic_default = data['ic_default_id']
+
+        sql = (
+            "INSERT INTO " +
+            "initial_conditions_spec(id, ic_default, name, reach, " +
+            "start_kp, end_kp, concentration, eg, em, ed, rate, enabled) " +
+            "VALUES (" +
+            f"{self.id}, " +
+            f"{ic_default}, " +
+            f"'{self._db_format(self._name_section)}', " +
+            f"{self._reach}, " +
+            f"{self._start_kp}, " +
+            f"{self._end_kp}, " +
+            f"{self._concentration}, " +
+            f"{self._eg}, " +
+            f"{self._em}, " +
+            f"{self._ed}, " +
+            f"{self._rate}, " +
+            f"{self._enabled}" +
+            ")"
+        )
+        execute(sql)
+
+        return True
+
+    @property
+    def name(self):
+        return self._name_section
+
+    @name.setter
+    def name(self, name):
+        self._name_section = name
+        self._status.modified()
+
+    @property
+    def reach(self):
+        return self._reach
+
+    @reach.setter
+    def reach(self, reach):
+        self._reach = reach
+        self._status.modified()
+
+    @property
+    def start_kp(self):
+        return self._start_kp
+
+    @start_kp.setter
+    def start_kp(self, start_kp):
+        self._start_kp = start_kp
+        self._status.modified()
+
+    @property
+    def end_kp(self):
+        return self._end_kp
+
+    @end_kp.setter
+    def end_kp(self, end_kp):
+        self._end_kp = end_kp
+        self._status.modified()
+
+    @property
+    def concentration(self):
+        return self._concentration
+
+    @concentration.setter
+    def concentration(self, concentration):
+        self._concentration = concentration
+        self._status.modified()
+
+    @property
+    def eg(self):
+        return self._eg
+
+    @eg.setter
+    def eg(self, eg):
+        self._eg = eg
+        self._status.modified()
+
+    @property
+    def em(self):
+        return self._em
+
+    @em.setter
+    def em(self, em):
+        self._em = em
+        self._status.modified()
+
+    @property
+    def ed(self):
+        return self._ed
+
+    @ed.setter
+    def ed(self, ed):
+        self._ed = ed
+        self._status.modified()
+
+    @property
+    def rate(self):
+        return self._rate
+
+    @rate.setter
+    def rate(self, rate):
+        self._rate = rate
+        self._status.modified()
+
+    @property
+    def enabled(self):
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, enabled):
+        self._enabled = enabled
+        self._status.modified()
+
+
+
+
+
+
+
+
+

src/Model/LateralContributionsAdisTS/LateralContributionAdisTS.py

@@ -0,0 +1,215 @@
+# LateralContributionAdisTS.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import logging
+
+from tools import (
+    trace, timer,
+    old_pamhyr_date_to_timestamp,
+    date_iso_to_timestamp,
+    date_dmy_to_timestamp,
+)
+
+from Model.Tools.PamhyrDB import SQLSubModel
+from Model.Except import NotImplementedMethodeError
+
+logger = logging.getLogger()
+
+class LateralContributionAdisTS(SQLSubModel):
+    _sub_classes = []
+    _id_cnt = 0
+
+    def __init__(self, id: int = -1, pollutant: int = -1, name: str = "", status=None):
+        super(LateralContributionAdisTS, self).__init__()
+
+        self._status = status
+
+        if id == -1:
+            self.id = LateralContributionAdisTS._id_cnt
+        else:
+            self.id = id
+
+        self._pollutant = pollutant
+        self._edge = None
+        self._begin_kp = 0.0
+        self._end_kp = 0.0
+        self._data = []
+        self._header = ["time", "rate"]
+        self._types = [self.time_convert, float]
+
+        LateralContributionAdisTS._id_cnt = max(
+            LateralContributionAdisTS._id_cnt + 1, self.id)
+
+    @classmethod
+    def _db_create(cls, execute):
+        execute("""
+          CREATE TABLE lateral_contribution_adists(
+            id INTEGER NOT NULL PRIMARY KEY,
+            pollutant INTEGER NOT NULL,
+            edge INTEGER NOT NULL,
+            begin_kp REAL NOT NULL,
+            end_kp REAL NOT NULL,
+            FOREIGN KEY(pollutant) REFERENCES Pollutants(id),
+            FOREIGN KEY(edge) REFERENCES river_reach(id)
+          )
+        """)
+
+        execute("""
+          CREATE TABLE lateral_contribution_data_adists(
+            id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+            data0 TEXT NOT NULL,
+            data1 TEXT NOT NULL,
+            lc INTEGER,
+            FOREIGN KEY(lc) REFERENCES lateral_contribution(id)
+          )
+        """)
+
+        return cls._create_submodel(execute)
+
+    @classmethod
+    def _db_update(cls, execute, version):
+        return True
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = []
+
+        table = execute(
+            "SELECT id, pollutant, edge, begin_kp, end_kp " +
+            "FROM lateral_contribution_adists"
+        )
+
+        if table is not None:
+            for row in table:
+                lc = cls(
+                    id=row[0],
+                    pollutant=row[1],
+                    status=data['status']
+                )
+
+                lc.edge = row[2]
+                lc.begin_kp = row[3]
+                lc.end_kp = row[4]
+
+                values = execute(
+                    "SELECT data0, data1 FROM lateral_contribution_data_adists " +
+                    f"WHERE lc = '{lc.id}'"
+                )
+
+                # Write data
+                for v in values:
+                    data0 = lc._types[0](v[0])
+                    data1 = lc._types[1](v[1])
+                    # Replace data at pos ind
+                    lc._data.append((data0, data1))
+
+                new.append(lc)
+
+        return new
+
+    def _db_save(self, execute, data=None):
+
+        execute(f"DELETE FROM lateral_contribution_adists WHERE id = {self.id}")
+        execute(f"DELETE FROM lateral_contribution_data_adists WHERE lc = {self.id}")
+
+        sql = (
+            "INSERT INTO " +
+            "lateral_contribution_adists(id, pollutant, edge, begin_kp, end_kp) " +
+            "VALUES (" +
+            f"{self.id}, {self._pollutant}, {self.edge}, " +
+            f"{self._begin_kp}, {self._end_kp}" +
+            ")"
+        )
+        execute(sql)
+
+        for d in self._data:
+            data0 = self._db_format(str(d[0]))
+            data1 = self._db_format(str(d[1]))
+
+            sql = (
+                "INSERT INTO " +
+                "lateral_contribution_data_adists(data0, data1, lc) " +
+                f"VALUES ('{data0}', {data1}, {self.id})"
+            )
+            execute(sql)
+
+        return True
+
+    def __len__(self):
+        return len(self._data)
+
+    @classmethod
+    def time_convert(cls, data):
+        if type(data) is str:
+            if data.count("-") == 2:
+                return date_iso_to_timestamp(data)
+            if data.count("/") == 2:
+                return date_dmy_to_timestamp(data)
+            if data.count(":") == 3:
+                return old_pamhyr_date_to_timestamp(data)
+            if data.count(":") == 2:
+                return old_pamhyr_date_to_timestamp("00:" + data)
+            if data.count(".") == 1:
+                return round(float(data))
+
+        return int(data)
+
+    @property
+    def edge(self):
+        return self._edge
+
+    @edge.setter
+    def edge(self, edge):
+        self._edge = edge
+        self._status.modified()
+
+    @property
+    def header(self):
+        return self._header.copy()
+
+    @header.setter
+    def header(self, header):
+        self._header = header
+        self._status.modified()
+
+    @property
+    def pollutant(self):
+        return self._pollutant
+
+    @property
+    def data(self):
+        return self._data.copy()
+
+    @property
+    def begin_kp(self):
+        return self._begin_kp
+
+    @begin_kp.setter
+    def begin_kp(self, begin_kp):
+        self._begin_kp = begin_kp
+        self._status.modified()
+
+    @property
+    def end_kp(self):
+        return self._end_kp
+
+    @end_kp.setter
+    def end_kp(self, end_kp):
+        self._end_kp = end_kp
+        self._status.modified()
+

src/Model/LateralContributionsAdisTS/LateralContributionsAdisTSList.py

@@ -0,0 +1,65 @@
+# LateralContributionsAdisTSList.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+from copy import copy
+from tools import trace, timer
+
+from Model.Tools.PamhyrList import PamhyrModelList
+from Model.Except import NotImplementedMethodeError
+
+from Model.LateralContributionsAdisTS.LateralContributionAdisTS import LateralContributionAdisTS
+
+class LateralContributionsAdisTSList(PamhyrModelList):
+    _sub_classes = [
+        LateralContributionAdisTS,
+    ]
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = cls(status=data['status'])
+
+        if data is None:
+            data = {}
+
+        new._lst = LateralContributionAdisTS._db_load(
+            execute, data
+        )
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        execute("DELETE FROM lateral_contribution_adists")
+        execute("DELETE FROM lateral_condition_data_adists")
+
+        if data is None:
+            data = {}
+
+        for lc in self._lst:
+            lc._db_save(execute, data=data)
+
+        return True
+
+    def new(self, index, pollutant):
+        n = LateralContributionAdisTS(pollutant=pollutant, status=self._status)
+        self._lst.insert(index, n)
+        self._status.modified()
+        return n
+
+    @property
+    def Lat_Cont_List(self):
+        return self.lst

src/Model/Network/Graph.py

@@ -142,26 +142,21 @@ class Graph(object):
     def insert_node(self, node):
         return self._add_node(node)
 
-    def remove_node(self, node_name: str):
-        self._nodes = list(
-            filter(
-                lambda n: n.name != node_name,
-                self._nodes
-            )
-        )
-        self._remove_associated_edge(node_name)
+    def remove_node(self, node):
+        self._nodes.remove(node)
+        self._remove_associated_edge(node)
         self._status.modified()
 
-    def _remove_associated_edge(self, node_name: str):
+    def _remove_associated_edge(self, node: str):
         edges = list(
             filter(
-                lambda e: (e.node1.name == node_name or
-                           e.node2.name == node_name),
+                lambda e: (e.node1 == node or
+                           e.node2 == node),
                 self._edges,
             )
         )
         for edge in edges:
-            self.remove_edge(edge.name)
+            self.remove_edge(edge)
 
     def create_node(self, x: float = 0.0, y: float = 0.0):
         node = self._create_node(x, y)
@@ -176,11 +171,11 @@ class Graph(object):
         return edge
 
     def _add_edge(self, edge):
-        # This edge already exists ?
-        if any(filter(lambda e: (e.node1 == edge.node1 and
-                                 e.node2 == edge.node2),
-                      self._edges)):
-            return None
+        # # This edge already exists ?
+        # if any(filter(lambda e: (e.node1 == edge.node1 and
+        #                          e.node2 == edge.node2),
+        #               self._edges)):
+        #     return None
 
         self._edges.append(edge)
 
@@ -197,13 +192,8 @@ class Graph(object):
     def create_edge(self, n1: Node, n2: Node):
         return self._create_edge(n1, n2)
 
-    def remove_edge(self, edge_name: str):
-        self._edges = list(
-            filter(
-                lambda e: e.name != edge_name,
-                self._edges
-            )
-        )
+    def remove_edge(self, edge):
+        self._edges.remove(edge)
         self._status.modified()
 
     def is_upstream_node(self, node):

src/Model/Network/test_network.py

@@ -60,7 +60,7 @@ class GraphTestCase(unittest.TestCase):
 
         e0 = g.add_edge(n0, n1)
 
-        g.remove_edge(e0.name)
+        g.remove_edge(e0)
 
         self.assertEqual(g.nodes_counts(), 2)
         self.assertEqual(g.edges_counts(), 0)
@@ -73,7 +73,7 @@ class GraphTestCase(unittest.TestCase):
 
         e0 = g.add_edge(n0, n1)
 
-        g.remove_node(n0.name)
+        g.remove_node(n0)
 
         self.assertEqual(g.nodes_counts(), 1)
         self.assertEqual(g.edges_counts(), 0)
@@ -88,7 +88,7 @@ class GraphTestCase(unittest.TestCase):
         e0 = g.add_edge(n0, n1)
         e1 = g.add_edge(n1, n2)
 
-        g.remove_node(n1.name)
+        g.remove_node(n1)
 
         self.assertEqual(g.nodes_counts(), 2)
         self.assertEqual(g.edges_counts(), 0)

src/Model/OutputKpAdists/OutputKpAdists.py

@@ -0,0 +1,164 @@
+# OutputKpAdists.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import logging
+
+from tools import (
+    trace, timer,
+    old_pamhyr_date_to_timestamp,
+    date_iso_to_timestamp,
+    date_dmy_to_timestamp,
+)
+
+from Model.Tools.PamhyrDB import SQLSubModel
+from Model.Except import NotImplementedMethodeError
+
+logger = logging.getLogger()
+
+class OutputKpAdists(SQLSubModel):
+    _sub_classes = []
+    _id_cnt = 0
+
+    def __init__(self, id: int = -1, reach = None, kp = None, title: str = "",  status=None):
+        super(OutputKpAdists, self).__init__()
+
+        self._status = status
+
+        if id == -1:
+            self.id = OutputKpAdists._id_cnt
+        else:
+            self.id = id
+
+        self._reach = reach
+        self._kp = kp
+        self._title = str(title)
+        self._enabled = True
+
+        OutputKpAdists._id_cnt = max(
+            OutputKpAdists._id_cnt + 1, self.id)
+
+    @property
+    def reach(self):
+        return self._reach
+
+    @reach.setter
+    def reach(self, reach_id):
+        self._reach = reach_id
+        self._status.modified()
+
+    @property
+    def kp(self):
+        return self._kp
+
+    @kp.setter
+    def kp(self, profile_id):
+        self._kp = profile_id
+        self._status.modified()
+
+    @property
+    def title(self):
+        return self._title
+
+    @title.setter
+    def title(self, title):
+        self._title = title
+        self._status.modified()
+
+
+    @classmethod
+    def _db_create(cls, execute):
+
+        sql = (
+            "CREATE TABLE OutputKpAdists(" +
+            "id INTEGER NOT NULL PRIMARY KEY, " +
+            "reach INTEGER NOT NULL, " +
+            "kp REAL NOT NULL, " +
+            "title TEXT NOT NULL, " +
+            "FOREIGN KEY(reach) REFERENCES river_reach(id)" +
+            ")"
+        )
+
+        execute(sql)
+
+        return cls._create_submodel(execute)
+
+    @classmethod
+    def _db_update(cls, execute, version):
+        return True
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = []
+
+        #reach   = data["reach"]
+        #profile = data["profile"]
+        status  = data["status"]
+
+        table = execute(
+            "SELECT id, reach, kp, title " +
+            f"FROM OutputKpAdists"
+        )
+
+        if table is not None:
+            for row in table:
+                id       = row[0]
+                id_reach = row[1]
+                id_kp    = row[2]
+                title    = row[3]
+
+                new_output = cls(
+                    id=id, reach=id_reach,
+                    kp=id_kp, title=title,
+                    status=status
+                )
+
+                new.append(new_output)
+
+        return new
+
+    def _db_save(self, execute, data=None):
+
+        execute(f"DELETE FROM OutputKpAdists WHERE id = {self.id}")
+
+        sql = (
+            "INSERT INTO " +
+            "OutputKpAdists(id, reach, kp, title) " +
+            "VALUES (" +
+            f"{self.id}, {self._reach}, {self._kp}, " +
+            f"'{self._db_format(self._title)}'" +
+            ")"
+        )
+
+        execute(sql)
+
+        return True
+
+    @property
+    def enabled(self):
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, enabled):
+        self._enabled = enabled
+        self._status.modified()
+
+
+
+
+
+

src/Model/OutputKpAdists/OutputKpListAdists.py

@@ -0,0 +1,56 @@
+# OutputKpListAdists.py -- Pamhyr
+# Copyright (C) 2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+from tools import trace, timer
+
+from Model.Except import NotImplementedMethodeError
+from Model.Tools.PamhyrList import PamhyrModelList
+from Model.OutputKpAdists.OutputKpAdists import OutputKpAdists
+
+
+class OutputKpAdistsList(PamhyrModelList):
+    _sub_classes = [OutputKpAdists]
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = cls(status=data["status"])
+
+        new._lst = OutputKpAdists._db_load(execute, data)
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        ok = True
+
+        # Delete previous data
+        execute("DELETE FROM OutputKpAdists")
+
+        for sl in self._lst:
+            ok &= sl._db_save(execute, data)
+
+        return ok
+
+    @property
+    def OutputKp_List(self):
+        return self.lst
+
+    def new(self, lst, index):
+        n = OutputKpAdists(status=self._status)
+        self._lst.insert(index, n)
+        self._status.modified()
+        return n

src/Model/Pollutants/Pollutants.py

@@ -0,0 +1,186 @@
+# Pollutants.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import logging
+
+from tools import (
+    trace, timer,
+    old_pamhyr_date_to_timestamp,
+    date_iso_to_timestamp,
+    date_dmy_to_timestamp,
+)
+
+from Model.Tools.PamhyrDB import SQLSubModel
+from Model.Except import NotImplementedMethodeError
+
+logger = logging.getLogger()
+
+class Pollutants(SQLSubModel):
+    _sub_classes = []
+    _id_cnt = 0
+
+    def __init__(self, id: int = -1, name: str = "",  status=None):
+        super(Pollutants, self).__init__()
+
+        self._status = status
+
+        if id == -1:
+            self.id = Pollutants._id_cnt
+        else:
+            self.id = id
+
+        self._name = str(name)
+        self._enabled = True
+
+        self._data = []
+
+        Pollutants._id_cnt = max(
+            Pollutants._id_cnt + 1, self.id)
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, name):
+        self._name = name
+        self._status.modified()
+
+    @property
+    def data(self):
+        return self._data.copy()
+
+    @classmethod
+    def _db_create(cls, execute):
+        execute("""
+          CREATE TABLE Pollutants(
+            id INTEGER NOT NULL PRIMARY KEY,
+            name TEXT NOT NULL UNIQUE
+          )
+        """)
+
+        execute("""
+          CREATE TABLE Pollutants_characteristics(
+            id INTEGER NOT NULL PRIMARY KEY,
+            type INTEGER NOT NULL,
+            diametre REAL NOT NULL,
+            rho REAL NOT NULL,
+            porosity REAL NOT NULL,
+            cdc_riv REAL NOT NULL,
+            cdc_cas REAL NOT NULL,
+            apd REAL NOT NULL,
+            ac REAL NOT NULL,
+            bc REAL NOT NULL,
+            pollutant INTEGER NOT NULL,
+            FOREIGN KEY(pollutant) REFERENCES Pollutants(id)
+          )
+        """)
+
+        return cls._create_submodel(execute)
+
+    @classmethod
+    def _db_update(cls, execute, version):
+        return True
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = []
+
+        status  = data["status"]
+
+        table = execute(
+            "SELECT id, name " +
+            f"FROM Pollutants"
+        )
+
+        if table is not None:
+            for row in table:
+                id   = row[0]
+                name = row[1]
+
+                new_pollutant = cls(
+                    id=id, name=name,
+                    status=status
+                )
+
+                new_data = []
+                table = execute(
+                    "SELECT * " +
+                    "FROM Pollutants_characteristics " +
+                    f"WHERE pollutant = {id}"
+                )
+
+                if table is not None:
+                    for t in table:
+                        new_data = t[1:]
+
+                new_pollutant._data.append(new_data)
+
+                new.append(new_pollutant)
+
+        return new
+
+    def _db_save(self, execute, data=None):
+
+        execute(f"DELETE FROM Pollutants WHERE id = {self.id}")
+        execute(f"DELETE FROM Pollutants_characteristics WHERE pollutant = {self.id}")
+
+        sql = (
+            "INSERT INTO " +
+            "Pollutants(id, name) " +
+            "VALUES (" +
+            f"{self.id}, " +
+            f"'{self._db_format(self._name)}'" +
+            ")"
+        )
+
+        execute(sql)
+
+        for d in self._data:
+            sql = (
+                "INSERT INTO " +
+                "Pollutants_characteristics(type, diametre, rho, porosity, " +
+                "cdc_riv, cdc_cas, apd, ac, bc, pollutant) " +
+                f"VALUES ({d[0]}, {d[1]}, {d[2]},{d[3]}, {d[4]}, "
+                f"{d[5]}, {d[6]}, {d[7]}, {d[8]}, {self.id})"
+            )
+            execute(sql)
+
+        return True
+
+    @property
+    def enabled(self):
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, enabled):
+        self._enabled = enabled
+        self._status.modified()
+
+    def is_define(self):
+        return len(self._data) != 0
+
+    def __len__(self):
+        return len(self._data)
+
+
+
+
+
+
+

src/Model/Pollutants/PollutantsList.py

@@ -0,0 +1,56 @@
+# PollutantsList.py -- Pamhyr
+# Copyright (C) 2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+from tools import trace, timer
+
+from Model.Except import NotImplementedMethodeError
+from Model.Tools.PamhyrList import PamhyrModelList
+from Model.Pollutants.Pollutants import Pollutants
+
+
+class PollutantsList(PamhyrModelList):
+    _sub_classes = [Pollutants]
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = cls(status=data["status"])
+
+        new._lst = Pollutants._db_load(execute, data)
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        ok = True
+
+        # Delete previous data
+        execute("DELETE FROM Pollutants")
+
+        for sl in self._lst:
+            ok &= sl._db_save(execute, data)
+
+        return ok
+
+    @property
+    def Pollutants_List(self):
+        return self.lst
+
+    def new(self, lst, index):
+        n = Pollutants(status=self._status)
+        self._lst.insert(index, n)
+        self._status.modified()
+        return n

src/Model/Results/ResultsAdisTS.py

@@ -0,0 +1,83 @@
+# Results.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import logging
+import numpy as np
+import os, glob
+
+from copy import deepcopy
+from datetime import datetime
+
+from Model.Results.River.RiverAdisTS import River
+
+logger = logging.getLogger()
+
+
+class Results(object):
+    def __init__(self, study=None, solver=None,
+                 repertory="", name="0"):
+        self._study = study
+        self._solver = solver
+        self._repertory = repertory
+        self._name = name
+
+        self._river = River(self._study)
+
+        self._meta_data = {
+            # Keep results creation date
+            "creation_date": datetime.now(),
+        }
+
+        repertory_results = os.path.join(repertory, "resultats")
+        self._pollutants_list = [el.split("/")[-1][0:-4] for el in glob.glob(repertory_results + "/*.bin")]
+
+        self._phys_var_list = ["C", "G", "M", "D", "L", "N", "R"]
+
+        print("*********files names resultats from Results Object: ", self._pollutants_list)
+
+    @property
+    def date(self):
+        date = self._meta_data["creation_date"]
+        return f"{date.isoformat(sep=' ')}"
+
+    @property
+    def river(self):
+        return self._river
+
+    @property
+    def study(self):
+        return self._study
+
+    @property
+    def pollutants_list(self):
+        return self._pollutants_list
+
+    @property
+    def phys_var_list(self):
+        return self._phys_var_list
+
+    def set(self, key, value):
+        self._meta_data[key] = value
+
+    def get(self, key):
+        return self._meta_data[key]
+
+    def reload(self):
+        return self._solver.results(
+            self._study,
+            self._repertory,
+            qlog=None,
+        )

src/Model/Results/River/River.py

@@ -126,3 +126,11 @@ class River(object):
 
         self._reachs.append(new)
         return new
+
+    def get_reach_by_geometry(self, geometry_reach):
+        return next(
+            filter(
+                lambda r: r.geometry is geometry_reach,
+                self._reachs
+            )
+        )

src/Model/Results/River/RiverAdisTS.py

@@ -0,0 +1,136 @@
+# River.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+import logging
+
+from datetime import datetime
+
+logger = logging.getLogger()
+
+
+class Profile(object):
+    def __init__(self, profile, study):
+        self._study = study
+        self._profile = profile  # Source profile in the study
+        self._data = {}  # Dict of dict {<ts>: {<key>: <value>, ...}, ...}
+
+    def __len__(self):
+        return len(self._data)
+
+    @property
+    def name(self):
+        return self._profile.name
+
+    @property
+    def kp(self):
+        return self._profile.kp
+
+    @property
+    def geometry(self):
+        return self._profile
+
+    def set(self, timestamp, key, data):
+        if timestamp not in self._data:
+            self._data[timestamp] = {}
+
+        self._data[timestamp][key] = data
+
+    def get_ts(self, timestamp):
+        return self._data[timestamp]
+
+    def get_key(self, key):
+        return list(
+            map(lambda ts: self._data[ts][key], self._data)
+        )
+
+    def get_ts_key(self, timestamp, key):
+        return self._data[timestamp][key]
+
+    def has_sediment(self):
+        return any(map(lambda ts: "sl" in self._data[ts], self._data))
+
+
+class Reach(object):
+    def __init__(self, reach, study):
+        self._study = study
+        self._reach = reach  # Source reach in the study
+        self._profiles = list(
+            map(
+                lambda p: Profile(p, self._study),
+                reach.profiles
+            )
+        )
+
+    def __len__(self):
+        return len(self._profiles)
+
+    @property
+    def name(self):
+        return self._reach.name
+
+    @property
+    def geometry(self):
+        return self._reach
+
+    @property
+    def profiles(self):
+        return self._profiles.copy()
+
+    def profile(self, id):
+        return self._profiles[id]
+
+    def set(self, profile_id, timestamp, key, data):
+        self._profiles[profile_id].set(timestamp, key, data)
+
+    def has_sediment(self):
+        return any(map(lambda profile: profile.has_sediment(), self._profiles))
+
+
+class River(object):
+    def __init__(self, study):
+        self._study = study
+
+        # Dict with timestamps as key
+        self._reachs = []
+
+    def __len__(self):
+        return len(self._reachs)
+
+    @property
+    def reachs(self):
+        return self._reachs.copy()
+
+    def reach(self, id):
+        return self._reachs[id]
+
+    def has_reach(self, id):
+        return 0 <= id < len(self._reachs)
+
+    def add(self, reach_id):
+        reachs = self._study.river.enable_edges()
+
+        new = Reach(reachs[reach_id].reach, self._study)
+
+        self._reachs.append(new)
+        return new
+
+    def get_reach_by_geometry(self, geometry_reach):
+        return next(
+            filter(
+                lambda r: r.geometry is geometry_reach,
+                self._reachs
+            )
+        )

src/Model/River.py

@@ -45,6 +45,14 @@ from Model.REPLine.REPLineList import REPLineList
 
 from Solver.Solvers import solver_type_list
 
+from Model.OutputKpAdists.OutputKpListAdists import OutputKpAdistsList
+from Model.Pollutants.PollutantsList import PollutantsList
+from Model.InitialConditionsAdisTS.InitialConditionsAdisTSList import InitialConditionsAdisTSList
+from Model.BoundaryConditionsAdisTS.BoundaryConditionsAdisTSList import BoundaryConditionsAdisTSList
+from Model.LateralContributionsAdisTS.LateralContributionsAdisTSList import LateralContributionsAdisTSList
+from Model.D90AdisTS.D90AdisTSList import D90AdisTSList
+from Model.DIFAdisTS.DIFAdisTSList import DIFAdisTSList
+
 
 class RiverNode(Node, SQLSubModel):
     _sub_classes = []
@@ -228,6 +236,13 @@ class River(Graph, SQLSubModel):
         HydraulicStructureList,
         AddFileList,
         REPLineList,
+        OutputKpAdistsList,
+        PollutantsList,
+        InitialConditionsAdisTSList,
+        BoundaryConditionsAdisTSList,
+        LateralContributionsAdisTSList,
+        D90AdisTSList,
+        DIFAdisTSList,
     ]
 
     def __init__(self, status=None):
@@ -251,6 +266,13 @@ class River(Graph, SQLSubModel):
         )
         self._additional_files = AddFileList(status=self._status)
         self._rep_lines = REPLineList(status=self._status)
+        self._Output_kp_adists = OutputKpAdistsList(status=self._status)
+        self._Pollutants = PollutantsList(status=self._status)
+        self._InitialConditionsAdisTS = InitialConditionsAdisTSList(status=self._status)
+        self._BoundaryConditionsAdisTS = BoundaryConditionsAdisTSList(status=self._status)
+        self._LateralContributionsAdisTS = LateralContributionsAdisTSList(status=self._status)
+        self._D90AdisTS = D90AdisTSList(status=self._status)
+        self._DIFAdisTS = DIFAdisTSList(status=self._status)
 
     @classmethod
     def _db_create(cls, execute):
@@ -325,6 +347,22 @@ class River(Graph, SQLSubModel):
         )
         new._rep_lines = REPLineList._db_load(execute, data)
 
+        new._Output_kp_adists = OutputKpAdistsList._db_load(
+            execute, data
+        )
+
+        new._Pollutants = PollutantsList._db_load(execute, data)
+
+        new._InitialConditionsAdisTS = InitialConditionsAdisTSList._db_load(execute, data)
+
+        new._BoundaryConditionsAdisTS = BoundaryConditionsAdisTSList._db_load(execute, data)
+
+        new._LateralContributionsAdisTS = LateralContributionsAdisTSList._db_load(execute, data)
+
+        new._D90AdisTS = D90AdisTSList._db_load(execute, data)
+
+        new._DIFAdisTS = DIFAdisTSList._db_load(execute, data)
+
         return new
 
     def _db_save(self, execute, data=None):
@@ -344,6 +382,14 @@ class River(Graph, SQLSubModel):
         for solver in self._parameters:
             objs.append(self._parameters[solver])
 
+        objs.append(self._Output_kp_adists)
+        objs.append(self._Pollutants)
+        objs.append(self._InitialConditionsAdisTS)
+        objs.append(self._BoundaryConditionsAdisTS)
+        objs.append(self._LateralContributionsAdisTS)
+        objs.append(self._D90AdisTS)
+        objs.append(self._DIFAdisTS)
+
         self._save_submodel(execute, objs, data)
         return True
 
@@ -378,6 +424,7 @@ class River(Graph, SQLSubModel):
 
     def init_default(self):
         self.init_default_network()
+        self.init_default_sediment()
         self.init_default_additional_files()
 
     def init_default_network(self):
@@ -386,6 +433,20 @@ class River(Graph, SQLSubModel):
 
         e = self.add_edge(n1, n2)
 
+    def init_default_sediment(self):
+        sediment = self._sediment_layers
+        default = sediment.new(0)
+        default_0 = default.new(0)
+
+        default.name = "default"
+        default.comment = "Default sediment layers"
+
+        default_0.name = "L0"
+        default_0.height = 1.0
+        default_0.d50 = 0.002
+        default_0.sigma = 1.0
+        default_0.critical_constraint = 0.047
+
     def init_default_additional_files(self):
         add_file = self._additional_files.new(0)
         add_file.name = "Pamhyr2 stamp file"
@@ -451,6 +512,34 @@ Last export at: @date."""
     def parameters(self):
         return self._parameters
 
+    @property
+    def Output_kp_adists(self):
+        return self._Output_kp_adists
+
+    @property
+    def Pollutants(self):
+        return self._Pollutants
+
+    @property
+    def initial_conditions_adists(self):
+        return self._InitialConditionsAdisTS
+
+    @property
+    def boundary_conditions_adists(self):
+        return self._BoundaryConditionsAdisTS
+
+    @property
+    def lateral_contributions_adists(self):
+        return self._LateralContributionsAdisTS
+
+    @property
+    def d90_adists(self):
+        return self._D90AdisTS
+
+    @property
+    def dif_adists(self):
+        return self._DIFAdisTS
+
     def get_params(self, solver):
         if solver in self._parameters:
             return self._parameters[solver]

src/Model/Study.py

@@ -71,6 +71,8 @@ class Study(SQLModel):
         lst = [
             StudyNetworkReachChecker(),
             StudyGeometryChecker(),
+            StudyInitialConditionsChecker(),
+            #StudyBoundaryConditionChecker(),
             # DummyOK(),
             # DummyWARNING(),
             # DummyERROR(),

src/Modules.py

@@ -23,7 +23,20 @@ from enum import Flag, auto
 logger = logging.getLogger()
 
 
-class Modules(Flag):
+class IterableFlag(Flag):
+    def __iter__(self):
+        all = filter(
+            lambda v: v in self,
+            type(self).values()
+        )
+        return all
+
+    @classmethod
+    def values(cls):
+        raise Exception("Not implemented yet")
+
+
+class Modules(IterableFlag):
     NONE = 0
 
     # General
@@ -41,6 +54,7 @@ class Modules(Flag):
     RESERVOIR = auto()
     SEDIMENT_LAYER = auto()
     ADDITIONAL_FILES = auto()
+    OUTPUT_KP = auto()
 
     # Results
     RESULTS = auto()
@@ -48,6 +62,25 @@ class Modules(Flag):
     # Display
     WINDOW_LIST = auto()
 
+    @classmethod
+    def values(cls):
+        return [
+            cls.STUDY, cls.CONFIG,
+            cls.NETWORK,
+            cls.GEOMETRY,
+            cls.BOUNDARY_CONDITION,
+            cls.LATERAL_CONTRIBUTION,
+            cls.FRICTION,
+            cls.INITIAL_CONDITION,
+            cls.HYDRAULIC_STRUCTURES,
+            cls.RESERVOIR,
+            cls.SEDIMENT_LAYER,
+            cls.ADDITIONAL_FILES,
+            cls.RESULTS,
+            cls.WINDOW_LIST,
+            cls.OUTPUT_KP,
+        ]
+
     @classmethod
     def all(cls):
         return ~cls.NONE
@@ -93,3 +126,41 @@ class Modules(Flag):
             cls.RESERVOIR: "Reservoir",
             cls.SEDIMENT_LAYER: "Sediment layer",
         }
+
+    def impact(self):
+        res = Modules(0)
+        for mod in self:
+            if mod in _impact:
+                for i in _impact[mod]:
+                    res |= i
+        return res
+
+    def impact_set(self):
+        res = []
+        for mod in self:
+            if mod in _impact:
+                res += _impact[mod]
+
+        return set(res)
+
+
+_impact = {
+    Modules.NETWORK: [
+        Modules.GEOMETRY, Modules.BOUNDARY_CONDITION,
+        Modules.LATERAL_CONTRIBUTION, Modules.FRICTION,
+        Modules.RESERVOIR, Modules.SEDIMENT_LAYER,
+    ],
+    Modules.GEOMETRY: [
+        Modules.LATERAL_CONTRIBUTION, Modules.FRICTION,
+        Modules.INITIAL_CONDITION, Modules.SEDIMENT_LAYER,
+    ],
+    Modules.BOUNDARY_CONDITION: [
+        Modules.SEDIMENT_LAYER
+    ],
+    Modules.LATERAL_CONTRIBUTION: [],
+    Modules.FRICTION: [],
+    Modules.INITIAL_CONDITION: [],
+    Modules.HYDRAULIC_STRUCTURES: [],
+    Modules.RESERVOIR: [],
+    Modules.SEDIMENT_LAYER: [],
+}

src/Solver/AdisTS.py

@@ -0,0 +1,731 @@
+# AdisTS.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import os, glob
+import logging
+from http.cookiejar import reach
+
+import numpy as np
+
+import shutil
+
+from tools import (
+    trace, timer, logger_exception,
+    timestamp_to_old_pamhyr_date,
+    old_pamhyr_date_to_timestamp,
+    timestamp_to_old_pamhyr_date_adists
+)
+
+from Solver.CommandLine import CommandLineSolver
+
+from Model.Results.ResultsAdisTS import Results
+from Model.Results.River.River import River, Reach, Profile
+
+from Checker.Adists import (
+    AdistsOutputKpChecker,
+)
+
+logger = logging.getLogger()
+
+def adists_file_open(filepath, mode):
+    f = open(filepath, mode)
+
+    if "w" in mode:
+        # Write header
+        comment = "*"
+        if ".ST" in filepath:
+            comment = "#"
+
+        f.write(
+            f"{comment} " +
+            "This file is generated by PAMHYR, please don't modify\n"
+        )
+
+    return f
+
+class AdisTS(CommandLineSolver):
+    _type = "adists"
+
+    def __init__(self, name):
+        super(AdisTS, self).__init__(name)
+
+        self._type = "adists"
+
+        self._cmd_input = ""
+        self._cmd_solver = "@path @input -o @output"
+        self._cmd_output = ""
+
+    @classmethod
+    def default_parameters(cls):
+        lst = super(AdisTS, cls).default_parameters()
+
+        lst += [
+            ("adists_implicitation_parameter", "0.5"),
+            ("adists_timestep_screen", "60"),
+            ("adists_timestep_bin", "60"),
+            ("adists_timestep_csv", "60"),
+            ("adists_timestep_mage", "60"),
+            ("adists_initial_concentration", "60"),
+        ]
+
+        return lst
+
+    @classmethod
+    def checkers(cls):
+        lst = [
+            AdistsOutputKpChecker(),
+        ]
+
+        return lst
+
+    def cmd_args(self, study):
+        lst = super(AdisTS, self).cmd_args(study)
+        return lst
+
+    def input_param(self):
+        name = self._study.name
+        return f"{name}.REP"
+
+    def log_file(self):
+        name = self._study.name
+        return f"{name}.TRA"
+
+    def _export_REP_additional_lines(self, study, rep_file):
+        lines = filter(
+            lambda line: line.is_enabled(),
+            study.river.rep_lines.lines
+        )
+
+        for line in lines:
+            rep_file.write(line.line)
+
+    def _export_REP(self, study, repertory, mage_rep, files, qlog, name="0"):
+
+        if qlog is not None:
+            qlog.put("Export REP file")
+
+        # Write header
+        with adists_file_open(
+                os.path.join(
+                    repertory, f"{name}.REP"
+                ), "w+"
+        ) as f:
+
+            f.write(f"NET ../{mage_rep}/{name}.NET\n")
+            f.write(f"REP ../{mage_rep}/{name}.REP\n")
+
+            for file in files:
+                EXT = file.split('.')[1]
+                f.write(f"{EXT} {file}\n")
+
+            self._export_REP_additional_lines(study, f)
+
+        path_mage_net = os.path.join(os.path.abspath(os.path.join(repertory, os.pardir)), f"{mage_rep}/net")
+        path_adists_net = os.path.join(repertory, "net")
+
+        if os.path.exists(path_mage_net):
+            shutil.copytree(path_mage_net, path_adists_net, dirs_exist_ok=True)
+
+    @timer
+    def export(self, study, repertory, qlog=None):
+        self._study = study
+        name = study.name.replace(" ", "_")
+
+        self.export_additional_files(study, repertory, qlog, name=name)
+
+        return True
+
+    ###########
+    # RESULTS #
+    ###########
+
+    def read_bin(self, study, repertory, results, qlog=None, name="0"):
+        return
+
+    @timer
+    def results(self, study, repertory, qlog=None, name="0"):
+        results = Results(
+            study=study,
+            solver=self,
+            repertory=repertory,
+            name=name,
+        )
+        self.read_bin(study, repertory, results, qlog, name=name)
+
+        return results
+
+    def output_param(self):
+        name = ""
+        return f"{name}"
+
+################################
+# Adis-TS in low coupling mode #
+################################
+
+
+class AdisTSlc(AdisTS):
+    _type = "adistslc"
+
+    def __init__(self, name):
+        super(AdisTSlc, self).__init__(name)
+
+        self._type = "adistslc"
+
+    @classmethod
+    def default_parameters(cls):
+        lst = super(AdisTSlc, cls).default_parameters()
+
+        # Insert new parameters at specific position
+        names = list(map(lambda t: t[0], lst))
+
+        return lst
+
+    ##########
+    # Export #
+    ##########
+
+    def cmd_args(self, study):
+        lst = super(AdisTSlc, self).cmd_args(study)
+
+        return lst
+
+    def _export_POLs(self, study, repertory, qlog=None, name="0"):
+
+        files = []
+
+        if qlog is not None:
+            qlog.put("Export POLS files")
+
+        pollutants = study.river.Pollutants.Pollutants_List
+
+        for pollutant in pollutants:
+            name = pollutant.name
+            with adists_file_open(os.path.join(repertory, f"{name}.POL"), "w+") as f:
+                files.append(f"{name}.POL")
+                f.write(f"*Polluant A contaminé aux PCB\n")
+                f.write(f"name = {name}\n")
+
+                self._export_POL_Characteristics(study, pollutant._data, f, qlog)
+
+                POL_ICs = next(filter(lambda ic: ic.pollutant == pollutant.id,\
+                                      study.river.initial_conditions_adists.Initial_Conditions_List))
+
+                if POL_ICs.concentration != None:
+                    f.write(f"file_ini = {name}.INI\n")
+                    self._export_ICs_AdisTS(study, repertory, POL_ICs, qlog, name)
+
+                POL_BCs = list(filter(lambda bc: bc.pollutant == pollutant.id,\
+                                      study.river.boundary_conditions_adists.BCs_AdisTS_List))
+
+                if len(POL_BCs) != 0:
+                    f.write(f"file_cl = {name}.CDT\n")
+                    self._export_BCs_AdisTS(study, repertory, POL_BCs, qlog, name)
+
+                POL_LAT_Cont = list(filter(lambda lc: lc.pollutant == pollutant.id,\
+                                      study.river.lateral_contributions_adists.Lat_Cont_List))
+
+                if len(POL_LAT_Cont) != 0:
+                    f.write(f"file_ald = {name}.ALD\n")
+                    f.write(f"*\n")
+                    self._export_Lat_AdisTS(study, repertory, POL_LAT_Cont, qlog, name)
+
+        return files
+
+    def _export_Lat_AdisTS(self, study, repertory, POL_LC, qlog, POL_name):
+
+        if qlog is not None:
+            qlog.put("Export POL LCs files")
+
+        with adists_file_open(os.path.join(repertory, f"{POL_name}.ALD"), "w+") as f:
+            for LC in POL_LC:
+                reach_name = next(filter(lambda edge: edge.id == LC.edge, study.river.edges())).name
+                f.write(f"${reach_name} {LC.begin_kp} {LC.end_kp}\n")
+                f.write(f"*temps   |débit massique (kg/s)\n")
+                f.write(f"*---------++++++++++\n")
+
+                for LC_data in LC._data:
+                    f.write(f"{timestamp_to_old_pamhyr_date_adists(int(LC_data[0]))} {LC_data[1]}\n")
+                f.write(f"*\n")
+
+        return True
+
+    def _export_BCs_AdisTS(self, study, repertory, POL_BC, qlog, POL_name):
+
+        if qlog is not None:
+            qlog.put("Export POL BCs files")
+
+        with adists_file_open(os.path.join(repertory, f"{POL_name}.CDT"), "w+") as f:
+            for BC in POL_BC:
+                node_name = next(filter(lambda x: x.id == BC.node, study.river._nodes)).name
+                f.write(f"${node_name}\n")
+
+                if BC.type == "Concentration":
+                    f.write(f"*temps |concentration\n")
+                    f.write(f"*JJ:HH:MM | (g/L)\n")
+                    f.write(f"*---------++++++++++\n")
+                else:
+                    f.write(f"*temps |rate\n")
+                    f.write(f"*JJ:HH:MM | (kg/s)\n")
+                    f.write(f"*---------++++++++++\n")
+
+                for BC_data in BC._data:
+                    f.write(f"{timestamp_to_old_pamhyr_date_adists(int(BC_data[0]))} {BC_data[1]}\n")
+                f.write(f"*\n")
+
+        return True
+
+    def _export_ICs_AdisTS(self, study, repertory, POL_IC_default, qlog, POL_name):
+
+        if qlog is not None:
+            qlog.put("Export POL ICs files")
+
+        with adists_file_open(os.path.join(repertory, f"{POL_name}.INI"), "w+") as f:
+            f.write(f"*État initial pour le polluant {POL_name}\n")
+            f.write(f"{POL_IC_default.name} = {POL_IC_default.concentration} {POL_IC_default.eg} "+
+            f"{POL_IC_default.em} {POL_IC_default.ed}\n")
+
+            if len(POL_IC_default._data) != 0:
+                self._export_ICs_AdisTS_Spec(study, POL_IC_default._data, f, qlog)
+
+    def _export_ICs_AdisTS_Spec(self, study, pol_ics_spec_data, f, qlog, name="0"):
+
+        for ic_spec in pol_ics_spec_data:
+            f.write(f"{ic_spec.name} = {ic_spec.reach} {ic_spec.start_kp} {ic_spec.end_kp} " +
+                    f"{ic_spec.concentration} {ic_spec.eg} {ic_spec.em} {ic_spec.ed} {ic_spec.rate}")
+
+        return True
+
+    def _export_POL_Characteristics(self, study, pol_data, f, qlog, name="0"):
+
+        list_characteristics = ["type", "diametre", "rho", "porosity", "cdc_riv", "cdc_cas", "apd", "ac", "bc"]
+
+        if len(list_characteristics) == (len(pol_data[0])-1):
+            for l in range(len(list_characteristics)):
+                f.write(f"{list_characteristics[l]} = {pol_data[0][l]}\n")
+
+    def _export_D90(self, study, repertory, qlog=None, name="0"):
+
+        files = []
+
+        if qlog is not None:
+            qlog.put("Export D90 file")
+
+        with adists_file_open(os.path.join(repertory, f"{name}.D90"), "w+") as f:
+            files.append(f"{name}.D90")
+
+            f.write(f"*Diamètres caractéristiques du fond stable\n")
+
+            d90AdisTS = study.river.d90_adists.D90_AdisTS_List
+
+            f.write(f"{d90AdisTS[0].name} = {d90AdisTS[0].d90}\n")
+
+            self._export_d90_spec(study, d90AdisTS[0]._data, f, qlog)
+
+        return files
+
+    def _export_d90_spec(self, study, d90_spec_data, f, qlog, name="0"):
+
+        for d90_spec in d90_spec_data:
+            if (d90_spec.name is None) or (d90_spec.reach is None) or (d90_spec.start_kp is None) or \
+                (d90_spec.end_kp is None) or (d90_spec.d90 is None):
+                return
+
+            edges = study.river.enable_edges()
+
+            id_edges = list(map(lambda x: x.id, edges))
+
+            id_reach = d90_spec.reach
+
+            if id_reach not in id_edges:
+                return
+
+            f.write(f"{d90_spec.name} = {id_reach} {d90_spec.start_kp} {d90_spec.end_kp} {d90_spec.d90}\n")
+
+    def _export_DIF(self, study, repertory, qlog=None, name="0"):
+
+        files = []
+
+        if qlog is not None:
+            qlog.put("Export DIF file")
+
+        with adists_file_open(os.path.join(repertory, f"{name}.DIF"), "w+") as f:
+            files.append(f"{name}.DIF")
+
+            f.write(f"*Définition des paramètres des fonctions de calcul du\n")
+            f.write(f"*coefficient de diffusion\n")
+
+            difAdisTS = study.river.dif_adists.DIF_AdisTS_List
+
+            if difAdisTS[0].method != "generique":
+                f.write(f"defaut = {difAdisTS[0].method} {difAdisTS[0].dif }\n")
+            else:
+                f.write(f"defaut = {difAdisTS[0].method} {difAdisTS[0].dif} {difAdisTS[0].b} {difAdisTS[0].c}\n")
+
+            self._export_dif_spec(study, difAdisTS[0]._data, f, qlog)
+
+        return files
+
+    def _export_dif_spec(self, study, dif_spec_data, f, qlog, name="0"):
+
+        for dif_spec in dif_spec_data:
+            if (dif_spec.reach is None) or (dif_spec.start_kp is None) or \
+                (dif_spec.end_kp is None) or (dif_spec.dif is None) or (dif_spec.b is None) or (dif_spec.c is None):
+                return
+
+            edges = study.river.enable_edges()
+
+            id_edges = list(map(lambda x: x.id, edges))
+
+            id_reach = dif_spec.reach
+
+            if id_reach not in id_edges:
+                return
+
+            if dif_spec.method != "generique":
+                f.write(f"{dif_spec.method} = {id_reach} {dif_spec.start_kp} {dif_spec.end_kp} {dif_spec.dif}\n")
+            else:
+                f.write(f"{dif_spec.method} = {id_reach} {dif_spec.start_kp} {dif_spec.end_kp} {dif_spec.dif}" +
+                f"{dif_spec.b} {dif_spec.c}\n")
+
+    def _export_NUM(self, study, repertory, qlog=None, name="0"):
+
+        dict_names = {"init_time":"start_date",
+                      "final_time":"end_date",
+                      "timestep":"dt0",
+                      "implicitation_parameter":"theta",
+                      "timestep_screen":"dtscr",
+                      "timestep_bin":"dtbin",
+                      "timestep_csv":"dtcsv",
+                      "timestep_mage":"dtMage",
+                      "initial_concentration":"c_initiale"}
+        files = []
+
+        if qlog is not None:
+            qlog.put("Export NUM file")
+
+        with adists_file_open(os.path.join(repertory, f"{name}.NUM"), "w+") as f:
+            files.append(f"{name}.NUM")
+
+            params = study.river.get_params(self.type).parameters
+            for p in params:
+                name = p.name\
+                        .replace("all_", "")\
+                        .replace("adists_", "")
+                value = p.value
+
+                logger.debug(
+                    f"export: NUM: {name}: {value} ({p.value})"
+                )
+
+                if name != "command_line_arguments":
+                    f.write(f"{dict_names[name]} = {value}\n")
+
+            outputkps = study.river.Output_kp_adists.OutputKp_List
+
+            for outputkp in outputkps:
+                self._export_outputkp(study, outputkp, f, qlog)
+
+        return files
+
+    def _export_outputkp(self, study, outputkp, f, qlog, name="0"):
+        if (outputkp.reach is None) or (outputkp.kp is None) or (outputkp.title is None):
+            return
+
+        edges = study.river.enable_edges()
+
+        id_edges = list(map(lambda x: x.id, edges))
+
+        id_reach = outputkp.reach
+        kp = outputkp.kp
+        title = outputkp.title
+
+        if id_reach not in id_edges:
+            return
+
+        f.write(f"output = {id_reach} {kp} {title}\n")
+
+    @timer
+    def read_bin(self, study, repertory, results, qlog=None, name="0"):
+        repertory_results = os.path.join(repertory, "resultats")
+
+        files_bin_names = [el.split("/")[-1] for el in glob.glob(repertory_results+"/*.bin")]
+        print("files names resultats: ", files_bin_names)
+
+        ifilename = os.path.join(repertory_results, files_bin_names[0])
+
+        logger.info(f"read_bin: Start reading '{ifilename}' ...")
+
+        print("reading ", ifilename)
+        with open(ifilename, 'rb') as f:
+            # header
+            # first line
+            data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (start)
+            data = np.fromfile(f, dtype=np.int32, count=3)
+            ibmax = data[0]  # number of reaches
+            ismax = data[1]  # total number of cross sections
+            kbl = data[2] * -1  # block size for .BIN header
+            data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (end)
+            # second line
+            data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (start)
+            ibu = np.fromfile(f, dtype=np.int32, count=ibmax)
+            data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (end)
+            # third line
+            data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (start)
+            data = np.fromfile(f, dtype=np.int32, count=2 * ibmax)
+            is1 = np.zeros(ibmax, dtype=np.int32)
+            is2 = np.zeros(ibmax, dtype=np.int32)
+            print("nombre de biefs : ", ibmax)
+
+            logger.debug(f"read_bin: nb_reach = {ibmax}")
+            logger.debug(f"read_bin: nb_profile = {ismax}")
+
+            results.set("nb_reach", f"{ibmax}")
+            results.set("nb_profile", f"{ismax}")
+
+            reachs = []
+            iprofiles = {}
+            reach_offset = {}
+
+            for i in range(ibmax):
+                # Add results reach to reach list
+                r = results.river.add(i)
+                reachs.append(r)
+
+                is1[i] = data[2 * i] - 1 # first section of reach i (FORTRAN numbering)
+                is2[i] = data[2 * i + 1] - 1  # last section of reach i (FORTRAN numbering)
+
+                key = (is1[i], is2[i])
+                iprofiles[key] = r
+
+                reach_offset[r] = is1[i]
+
+            logger.debug(f"read_bin: iprofiles = {iprofiles}")
+
+            data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (end)
+            # fourth line
+            pk = np.zeros(ismax, dtype=np.float32)
+            for k in range(0, ismax, kbl):
+                data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (start)
+                pk[k:min(k + kbl, ismax)] = np.fromfile(f, dtype=np.float32, count=min(k + kbl, ismax) - k)
+                print("pk : ", pk)
+                data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (end)
+
+                # fifth line (useless)
+                data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (start)
+                zmin_OLD = np.fromfile(f, dtype=np.float32, count=1)[0]
+                print("zmin_OLD : ", zmin_OLD)
+                data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (end)
+                # sixth line
+                zf = np.zeros(ismax, dtype=np.float32)
+                z = np.zeros(ismax * 3, dtype=np.float32)
+                for k in range(0, ismax, kbl):
+                    data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (start)
+                    z[3 * k:3 * min(k + kbl, ismax)] = np.fromfile(f, dtype=np.float32,
+                                                                   count=3 * (min(k + kbl, ismax) - k))
+                    # z[i*3+1] and z[i*3+2] are useless
+                    data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (end)
+                zf = [z[i * 3] for i in range(ismax)]
+                print("zf : ", zf)
+                # seventh line (useless)
+                for k in range(0, ismax, kbl):
+                    data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (start)
+                    zero = np.fromfile(f, dtype=np.int32, count=ismax)
+                    print("zero : ", zero)
+                    data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (end)
+                # end header
+
+        def ip_to_r(i): return iprofiles[
+            next(
+                filter(
+                    lambda k: k[0] <= i <= k[1],
+                    iprofiles
+                )
+            )
+        ]
+
+        def ip_to_ri(r, i): return i - reach_offset[r]
+
+        path_files = map(lambda file: os.path.join(repertory_results, file), files_bin_names)
+
+        data_tmp = {}
+
+        for file_bin in path_files:
+            key_pol = file_bin.split("/")[-1][0:-4]
+            data_tmp[key_pol] = {}
+            with open(file_bin, 'rb') as f:
+                # header
+                # first line
+                data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (start)
+                data = np.fromfile(f, dtype=np.int32, count=3)
+                ibmax = data[0]  # number of reaches
+                ismax = data[1]  # total number of cross sections
+                kbl = data[2] * -1  # block size for .BIN header
+                data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (end)
+                # second line
+                data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (start)
+                ibu = np.fromfile(f, dtype=np.int32, count=ibmax)
+                data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (end)
+                # third line
+                data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (start)
+                data = np.fromfile(f, dtype=np.int32, count=2 * ibmax)
+                is1 = np.zeros(ibmax, dtype=np.int32)
+                is2 = np.zeros(ibmax, dtype=np.int32)
+                for i in range(ibmax):
+                    is1[i] = data[2 * i]  # first section of reach i (FORTRAN numbering)
+                    is2[i] = data[2 * i + 1]  # last section of reach i (FORTRAN numbering)
+                data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (end)
+                # fourth line
+                pk = np.zeros(ismax, dtype=np.float32)
+                for k in range(0, ismax, kbl):
+                    data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (start)
+                    pk[k:min(k + kbl, ismax)] = np.fromfile(f, dtype=np.float32, count=min(k + kbl, ismax) - k)
+                    data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (end)
+                # fifth line (useless)
+                data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (start)
+                zmin_OLD = np.fromfile(f, dtype=np.float32, count=1)[0]
+                data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (end)
+                # sixth line
+                zf = np.zeros(ismax, dtype=np.float32)
+                z = np.zeros(ismax * 3, dtype=np.float32)
+                for k in range(0, ismax, kbl):
+                    data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (start)
+                    z[3 * k:3 * min(k + kbl, ismax)] = np.fromfile(f, dtype=np.float32,
+                                                                   count=3 * (min(k + kbl, ismax) - k))
+                    # z[i*3+1] and z[i*3+2] are useless
+                    data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (end)
+                zf = [z[i * 3] for i in range(ismax)]
+                # seventh line (useless)
+                for k in range(0, ismax, kbl):
+                    data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (start)
+                    zero = np.fromfile(f, dtype=np.int32, count=ismax)
+                    data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (end)
+                # end header
+                # data
+                data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (start)
+                while data.size > 0:
+                    ismax = np.fromfile(f, dtype=np.int32, count=1)[0]
+                    t = np.fromfile(f, dtype=np.float64, count=1)[0]
+                    if not t in data_tmp[key_pol]:
+                        data_tmp[key_pol][t] = {}
+                    c = np.fromfile(f, dtype=np.byte, count=1)
+                    # possible values :
+                    # sediment : C, G, M, D, L, N, R
+                    # polutant : C, G, M, D
+                    phys_var = bytearray(c).decode()
+                    data_tmp[key_pol][t][phys_var] = {}
+                    real_data = np.fromfile(f, dtype=np.float32, count=ismax)
+                    data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (end)
+                    data_tmp[key_pol][t][phys_var] = real_data
+                    data = np.fromfile(f, dtype=np.int32, count=1)  # line length (bytes) (start)
+                # end data
+
+        ###print("dta tmp AAA")
+        ###print("-----------")
+        ###print(data_tmp["AAA-silt"])
+
+        pollutants_keys = list(data_tmp.keys())
+        timestamps_keys = list(data_tmp[pollutants_keys[0]].keys())
+        phys_data_names = list(data_tmp[pollutants_keys[0]][timestamps_keys[0]].keys())
+
+        ###print("pol keys: ", pollutants_keys)
+        ###print("t keys: ", timestamps_keys)
+        ###print("phys var: ", phys_data_names)
+        #print("set timestamps keys: ", set(timestamps_keys))
+        #print("isma")
+        ###print("iprofiles: ", iprofiles)
+
+        pi_tmp = []
+        reach_tmp = []
+
+        for i in range(ismax-1):
+            #print("first i: ", i)
+            reach = ip_to_r(i)
+            reach_tmp.append(reach)
+            #print("reach i:", reach)
+            #print("second i: ", i)
+            p_i = ip_to_ri(reach, i)
+            pi_tmp.append(p_i)
+
+            for t_data in timestamps_keys:
+                pol_view = []
+                for pol in pollutants_keys:
+                    #print("pol results: ", type(list(data_tmp[pol][t_data].values())))
+                    pol_view.append(tuple( list(map(lambda data_el: data_el[p_i], list(data_tmp[pol][t_data].values()))) ))
+
+                reach.set(p_i, t_data, "pols", pol_view)
+
+        ###print("pi_tmp: ", pi_tmp)
+        ###print("pol view: ", pol_view)
+        ###print("reach from i: ", reach_tmp)
+        #print("pol view: ", pol_view)
+        #print("results: ", results)
+        results.set("timestamps", set(timestamps_keys))
+        #print("------------------------set timestamps results meta data: ", set(timestamps_keys))
+
+        ###print("debug profiles for draw:")
+        ###print("------------------------")
+        ###print(data_tmp["AAA-silt"][0.0]["C"][0])
+        ###print(data_tmp["AAA-silt"][600.0]["C"][0])
+        ###print(data_tmp["AAA-silt"][1205.7208829578194]["C"][0])
+        ###print("========================")
+
+    @timer
+    def results(self, study, repertory, qlog=None, name=None):
+        self._study = study
+        if name is None:
+            name = study.name.replace(" ", "_")
+
+        results = super(AdisTSlc, self).results(study, repertory, qlog, name=name)
+
+        return results
+
+    def export_func_dict(self):
+        return [
+            self._export_NUM,
+            self._export_DIF,
+            self._export_D90,
+            self._export_POLs,
+        ]
+
+    @timer
+    def export(self, study, repertory, mage_rep, qlog=None, name="0"):
+        print("cmd solver adistslc : ", self._cmd_solver)
+        self._study = study
+        name = study.name.replace(" ", "_")
+
+        # Generate files
+        files = []
+
+        try:
+            for func in self.export_func_dict():
+                files = files + func(study, repertory, qlog, name=name)
+
+            self.export_additional_files(study, repertory, qlog, name=name)
+            self._export_REP(study, repertory, mage_rep, files, qlog, name=name)
+
+            return True
+        except Exception as e:
+            logger.error(f"Failed to export study to {self._type}")
+            logger_exception(e)
+            return False
+
+
+
+
+
+

src/Solver/Mage.py

@@ -492,6 +492,9 @@ class Mage(CommandLineSolver):
                 if not hs.input_reach.is_enable():
                     continue
 
+                if not hs.enabled:
+                    continue
+
                 if hs.input_kp is None:
                     continue
 
@@ -507,25 +510,26 @@ class Mage(CommandLineSolver):
 
     def _export_SIN_bhs(self, study, sin_dict, hs, f):
         for bhs in hs.basic_structures:
-            reach_id = study.river.get_edge_id(hs.input_reach) + 1
-            param_str = ' '.join(
-                [
-                    f'{p:>10.3f}'
-                    for p in self._export_SIN_parameters(bhs)
-                ]
-            )
+            if bhs.enabled:
+                reach_id = study.river.get_edge_id(hs.input_reach) + 1
+                param_str = ' '.join(
+                    [
+                        f'{p:>10.3f}'
+                        for p in self._export_SIN_parameters(bhs)
+                    ]
+                )
 
-            name = bhs.name
-            if name == "":
-                name = f"HS_{bhs.id:>3}".replace(" ", "0")
-            else:
-                name = name.replace(" ", "_")
+                name = bhs.name
+                if name == "":
+                    name = f"HS_{bhs.id:>3}".replace(" ", "0")
+                else:
+                    name = name.replace(" ", "_")
 
-            f.write(
-                f"{sin_dict[bhs._type]} " +
-                f"{reach_id} {float(hs.input_kp):>12.3f} " +
-                f"{param_str} {name}\n"
-            )
+                f.write(
+                    f"{sin_dict[bhs._type]} " +
+                    f"{reach_id} {float(hs.input_kp):>12.3f} " +
+                    f"{param_str} {name}\n"
+                )
 
     def _export_SIN_parameters(self, bhs):
         res = [9999.999] * 5
@@ -799,7 +803,7 @@ class Mage8(Mage):
                     value = "O" if value.lower() == "y" else "N"
 
                 if name == "init_internal":
-                    value = ("p" if value.lower() in ["y", "yes", "true"]
+                    value = ("p" if value.lower() in ["y", "yes", "true", "o"]
                              else "")
 
                 logger.debug(
@@ -976,6 +980,7 @@ class Mage8(Mage):
 
                 # Add profile id correspondance to reach
                 key = (i1, i2)
+                print("mage keys reachs: ", key)
                 iprofiles[key] = r
 
                 # Profile ID offset
@@ -1008,6 +1013,8 @@ class Mage8(Mage):
             ]
             def ip_to_ri(r, i): return i - reach_offset[r]
 
+            print("mage iprofiles: ", iprofiles)
+
             ts = set()
             end = False
             while not end:
@@ -1043,6 +1050,7 @@ class Mage8(Mage):
 
             logger.debug(reachs[0].profiles[0]._data)
             results.set("timestamps", ts)
+            print("set timestamps mage: ", ts)
             logger.info(f"read_bin: ... end with {len(ts)} timestamp read")
 
     @timer

src/Solver/RubarBE.py

@@ -0,0 +1,441 @@
+# RubarBE.py -- Pamhyr
+# Copyright (C) 2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import os
+import logging
+import numpy as np
+
+from tools import timer, trace, old_pamhyr_date_to_timestamp
+
+from Solver.CommandLine import CommandLineSolver
+
+from Model.Results.Results import Results
+from Model.Results.River.River import River, Reach, Profile
+
+logger = logging.getLogger()
+
+
+class RubarBE(CommandLineSolver):
+    _type = "rubarbe"
+
+    def __init__(self, name):
+        super(RubarBE, self).__init__(name)
+
+        self._type = "rubarbe"
+
+        self._cmd_input = ""
+        self._cmd_solver = "@path @input -o @output"
+        self._cmd_output = ""
+
+    @classmethod
+    def default_parameters(cls):
+        lst = super(RubarBE, cls).default_parameters()
+
+        lst += [
+            ("rubarbe_cfl", "0.50000E+00"),
+            ("rubarbe_condam", "1"),
+            ("rubarbe_condav", "3"),
+            ("rubarbe_regime", "0"),
+            ("rubarbe_iodev", "n"),
+            ("rubarbe_iodebord", ""),
+            ("rubarbe_iostockage", ""),
+            ("rubarbe_iopdt", "y"),
+            ("rubarbe_iovis", "n"),
+            ("rubarbe_rep", "n"),
+            ("rubarbe_tinit", "000:00:00:00"),
+            ("rubarbe_tmax", "999:99:99:00"),
+            ("rubarbe_tiopdt", "000:00:00:00"),
+            ("rubarbe_dt", "3000.0"),
+            ("rubarbe_ts", "999:99:99:00"),
+            ("rubarbe_dtsauv", "999:99:99:00"),
+            ("rubarbe_psave", "999:99:99:00"),
+            ("rubarbe_fdeb1", "1"),
+            ("rubarbe_fdeb2", "10"),
+            ("rubarbe_fdeb3", "100"),
+            ("rubarbe_tf_1", "y"),
+            ("rubarbe_tf_2", "y"),
+            ("rubarbe_tf_3", "y"),
+            ("rubarbe_tf_4", "y"),
+            ("rubarbe_tf_5", "y"),
+            ("rubarbe_tf_6", "n"),
+            ("rubarbe_trased", "y"),
+            ("rubarbe_optfpc", "0"),
+            ("rubarbe_ros", "2650.0"),
+            ("rubarbe_dm", "0.1"),
+            ("rubarbe_segma", "1.0"),
+            # Sediment parameters
+            ("rubarbe_sediment_ros", "2650.0"),
+            ("rubarbe_sediment_por", "0.4"),
+            ("rubarbe_sediment_dcharg", "0.0"),
+            ("rubarbe_sediment_halfa", "1.0"),
+            ("rubarbe_sediment_mult_1", "1.0"),
+            ("rubarbe_sediment_mult_2", ""),
+            ("rubarbe_sediment_mult_3", ""),
+            ("rubarbe_sediment_mult_4", ""),
+            ("rubarbe_sediment_mult_5", ""),
+            ("rubarbe_sediment_visc", "0.047"),
+            ("rubarbe_sediment_opts", "6"),
+            ("rubarbe_sediment_odchar", "0"),
+            ("rubarbe_sediment_unisol", "1"),
+            ("rubarbe_sediment_typdef", "3"),
+            ("rubarbe_sediment_depot", "2"),
+            ("rubarbe_sediment_choixc", "2"),
+            ("rubarbe_sediment_option", "2"),
+            ("rubarbe_sediment_capsol", "1"),
+            ("rubarbe_sediment_bmiu", "0.85"),
+            ("rubarbe_sediment_demix", "0"),
+            ("rubarbe_sediment_defond", "1"),
+            ("rubarbe_sediment_varcons", "1"),
+            ("rubarbe_sediment_dchard", "0.0"),
+            ("rubarbe_sediment_dchars", "0.0"),
+        ]
+
+        return lst
+
+    @classmethod
+    def checkers(cls):
+        lst = [
+        ]
+
+        return lst
+
+    ##########
+    # Export #
+    ##########
+
+    def cmd_args(self, study):
+        lst = super(RubarBE, self).cmd_args(study)
+
+        return lst
+
+    def input_param(self):
+        name = self._study.name
+        return f"{name}.REP"
+
+    def output_param(self):
+        name = self._study.name
+        return f"{name}.BIN"
+
+    def log_file(self):
+        name = self._study.name
+        return f"{name}.TRA"
+
+    def export(self, study, repertory, qlog=None):
+        self._study = study
+        name = study.name.replace(" ", "_")
+
+        self._export_donnee(study, repertory, qlog, name=name)
+        self._export_ts(study, repertory, qlog, name=name)
+        self._export_geomac_i(study, repertory, qlog, name=name)
+        self._export_mail(study, repertory, qlog, name=name)
+        self._export_tps(study, repertory, qlog, name=name)
+        self._export_stricklers(study, repertory, qlog, name=name)
+
+    def _export_donnee(self, study, repertory, qlog, name="0"):
+        if qlog is not None:
+            qlog.put("Export DONNEE file")
+
+        with open(
+                os.path.join(
+                    repertory, f"donnee.{name}"
+                ), "w+"
+        ) as f:
+            params = filter(
+                lambda p: "rubarbe_sediment_" not in p.name,
+                study.river.get_params(self._type).parameters
+            )
+
+            it = iter(params)
+
+            line = 0
+            while line < 29:
+                param = next(it)
+                name = param.name
+                value = param.value
+
+                if value != "":
+                    # Value format
+                    if value.count(':') == 3:
+                        value = old_pamhyr_date_to_timestamp(value)
+                        value = f"{value:>12.5e}".upper()
+
+                    if value.count('.') == 1:
+                        value = f"{float(value):>12.5e}".upper()
+
+                    if value == "y" or value == "n":
+                        value = "O" if value == "y" else "N"
+
+                    # Write value
+                    f.write(f"{name:<50}{value}")
+
+                    # Add values of 'rubarbe_iodebord' and
+                    # 'rubarbe_iostockage'
+                    if name == "rubarbe_iodev":
+                        v2 = next(it).value
+                        v3 = next(it).value
+
+                        f.write(f"{v2}{v3}")
+
+                    # New line
+                    f.write(f"\n")
+
+                line += 1
+
+    def _export_ts(self, study, repertory, qlog, name="0"):
+        if qlog is not None:
+            qlog.put("Export TS file")
+
+        with open(
+                os.path.join(
+                    repertory, f"ts.{name}"
+                ), "w+"
+        ) as f:
+            def float_format(string):
+                if "." in string:
+                    return f"{float(string):>10.0f}"
+                return ""
+
+            params = filter(
+                lambda p: "rubarbe_sediment_" in p.name,
+                study.river.get_params(self.type).parameters
+            )
+            it = iter(params)
+
+            line = 0
+            while line < 20:
+                param = next(it)
+                name = param.name
+                value = param.value
+
+                if value != "":
+                    # Value format
+                    if value.count('.') == 1:
+                        value = f"{float_format(value)}"
+                    else:
+                        value = f"{value:>10}"
+
+                    # Write value
+                    f.write(f"{name:<50}{value}")
+
+                    # Add values of 'rubarbe_iodebord' and
+                    # 'rubarbe_iostockage'
+                    if name == "rubarbe_sediment_mult_1":
+                        m2 = f"{float_format(next(it).value)}"
+                        m3 = f"{float_format(next(it).value)}"
+                        m4 = f"{float_format(next(it).value)}"
+                        m5 = f"{float_format(next(it).value)}"
+
+                        f.write(f"{m2}{m3}{m4}{m5}")
+
+                    # New line
+                    f.write(f"\n")
+
+                line += 1
+
+    def _export_geomac_i(self, study, repertory, qlog, name="0"):
+        if qlog is not None:
+            qlog.put("Export GEOMAC-i file")
+
+        with open(
+                os.path.join(
+                    repertory, f"geomac-i.{name}"
+                ), "w+"
+        ) as f:
+            for edge in study.river.enable_edges():
+                reach = edge.reach
+                n_profiles = len(reach)
+                time = 0.0
+
+                f.write(f"{n_profiles:>5} {time:>11.3f}\n")
+
+                ind = 1
+                for profile in reach.profiles:
+                    kp = profile.kp
+                    n_points = len(profile)
+
+                    f.write(f"{ind:>4} {kp:>11.3f} {n_points:>4}\n")
+
+                    for point in profile.points:
+                        label = point.name.lower()
+                        if label != "":
+                            if label[0] == "r":
+                                label = label[1].upper()
+                            else:
+                                label = lable[0]
+
+                        y = point.y
+                        z = point.z
+                        dcs = 0.001
+                        scs = 1.0
+                        tmcs = 0.0
+
+                        f.write(
+                            f"{label} {y:>11.5f}" +
+                            f"{z:>13.5f}{dcs:>15.10f}" +
+                            f"{scs:>15.10f}{tmcs:>15.5f}" +
+                            "\n"
+                        )
+
+                    ind += 1
+
+    def _export_mail(self, study, repertory, qlog, name="0"):
+        if qlog is not None:
+            qlog.put("Export MAIL file")
+
+        with open(
+                os.path.join(
+                    repertory, f"mail.{name}"
+                ), "w+"
+        ) as f:
+            for edge in study.river.enable_edges():
+                reach = edge.reach
+                lm = len(reach) + 1
+                f.write(f"{lm:>13}\n")
+
+                for mails in [reach.inter_profiles_kp(),
+                              reach.get_kp()]:
+                    ind = 0
+                    for mail in mails:
+                        f.write(f"{mail:15.3f}")
+
+                        ind += 1
+                        if ind % 3 == 0:
+                            f.write("\n")
+
+                    if ind % 3 != 0:
+                        f.write("\n")
+
+    def _export_stricklers(self, study, repertory, qlog, name="0"):
+        self._export_frot(study, repertory, qlog, name=name, version="")
+        self._export_frot(study, repertory, qlog, name=name, version="2")
+
+    def _export_frot(self, study, repertory, qlog, name="0", version=""):
+        if qlog is not None:
+            qlog.put(f"Export FROT{version} file")
+
+        with open(
+                os.path.join(
+                    repertory, f"frot{version}.{name}"
+                ), "w+"
+        ) as f:
+            for edge in study.river.enable_edges():
+                reach = edge.reach
+                lm = len(reach) + 1
+                f.write(f"{lm:>6}\n")
+
+                def get_stricklers_from_kp(kp):
+                    return next(
+                        map(
+                            lambda s: (
+                                s.begin_strickler.medium if version == "2"
+                                else s.begin_strickler.minor
+                            ),
+                            filter(
+                                lambda f: kp in f,
+                                edge.frictions.lst
+                            )
+                        )
+                    )
+
+                ind = 1
+                for mail in edge.reach.inter_profiles_kp():
+                    coef = get_stricklers_from_kp(mail)
+
+                    f.write(f"{ind:>6} {coef:>12.5f}")
+
+                    ind += 1
+                    f.write("\n")
+
+    def _export_tps(self, study, repertory, qlog, name="0"):
+        if qlog is not None:
+            qlog.put("Export TPS file")
+
+        with open(
+                os.path.join(
+                    repertory, f"tps.{name}"
+                ), "w+"
+        ) as f:
+            for edge in study.river.enable_edges():
+                reach = edge.reach
+
+                f.write(f"0.0\n")
+
+                ics = study.river.initial_conditions.get(edge)
+                data = self._export_tps_init_data(ics)
+
+                profiles = reach.profiles
+                first = profiles[0]
+                last = profiles[-1]
+
+                if first.kp not in data or last.kp not in data:
+                    logger.error(
+                        "Study initial condition is not fully defined"
+                    )
+                    return
+
+                f_h_s = self._export_tps_profile_height_speed(first, data)
+                l_h_s = self._export_tps_profile_height_speed(last, data)
+
+                # First mail
+                f.write(f"{1:>5} {f_h_s[0]} {f_h_s[1]}")
+
+                ind = 2
+                it = iter(profiles)
+                prev = next(it)
+
+                prev_h, prev_s = f_h_s
+                for profile in it:
+                    if profile.kp not in data:
+                        ind += 1
+                        continue
+
+                    cur_h, cur_s = self._export_tps_profile_height_speed(
+                        profile, data
+                    )
+
+                    # Mean of height and speed
+                    h = (prev_h + cur_h) / 2
+                    s = (prev_s + cur_s) / 2
+
+                    f.write(f"{ind:>5} {h} {s}\n")
+
+                    prev_h, prev_s = cur_h, cur_s
+                    ind += 1
+
+                # Last mail
+                f.write(f"{ind:>5} {f_h_s[0]} {f_h_s[1]}")
+
+    def _export_tps_init_data(self, ics):
+        data = {}
+
+        for d in ics.data:
+            data[d['kp']] = (
+                d['elevation'],
+                d['discharge'],
+            )
+
+        return data
+
+    def _export_tps_profile_height_speed(self, profile, data):
+        z = data[profile.kp][0]
+        q = data[profile.kp][1]
+
+        height = z - profile.z_min()
+        speed = profile.speed(q, z)
+
+        return height, speed

src/Solver/Solvers.py

@@ -22,6 +22,8 @@ from Solver.GenericSolver import GenericSolver
 from Solver.Mage import (
     Mage7, Mage8, MageFake7,
 )
+from Solver.RubarBE import RubarBE
+from Solver.AdisTS import AdisTSlc
 
 _translate = QCoreApplication.translate
 
@@ -30,6 +32,8 @@ solver_long_name = {
     # "mage7": "Mage v7",
     "mage8": "Mage v8",
     # "mage_fake7": "Mage fake v7",
+    "rubarbe": "RubarBE",
+    "adistslc": "Adis-TS_LC",
 }
 
 solver_type_list = {
@@ -37,4 +41,6 @@ solver_type_list = {
     # "mage7": Mage7,
     "mage8": Mage8,
     # "mage_fake7": MageFake7,
+    "rubarbe": RubarBE,
+    "adistslc": AdisTSlc,
 }

src/View/About/Window.py

@@ -67,5 +67,5 @@ class AboutWindow(PamhyrDialog):
                     label = f"\n  - {author}" + label
             except StopIteration:
                 label = _translate("About", "Contributors: ") + label
-                label = "Copyright © 2023-2024  INRAE\n" + label
+                label = "Copyright © 2022-2024  INRAE\n" + label
                 self.set_label_text("label_copyright", label)

src/View/BoundaryConditionsAdisTS/Edit/Plot.py

@@ -0,0 +1,105 @@
+# Plot.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import logging
+
+from datetime import datetime
+
+from tools import timer, trace
+from View.Tools.PamhyrPlot import PamhyrPlot
+
+from PyQt5.QtCore import (
+    QCoreApplication
+)
+
+_translate = QCoreApplication.translate
+
+logger = logging.getLogger()
+
+
+class Plot(PamhyrPlot):
+    def __init__(self, mode="time", data=None,
+                 trad=None, canvas=None, toolbar=None,
+                 parent=None):
+        super(Plot, self).__init__(
+            canvas=canvas,
+            trad=trad,
+            data=data,
+            toolbar=toolbar,
+            parent=parent
+        )
+
+        self._table_headers = self._trad.get_dict("table_headers")
+
+        header = self.data.header
+
+        self.label_x = self._table_headers[header[0]]
+        self.label_y = self._table_headers[header[1]]
+
+        self._mode = mode
+        self._isometric_axis = False
+
+        self._auto_relim_update = True
+        self._autoscale_update = True
+
+    def custom_ticks(self):
+        if self.data.header[0] != "time":
+            return
+
+        self.set_ticks_time_formater()
+
+    @timer
+    def draw(self):
+        self.init_axes()
+
+        if len(self.data) == 0:
+            self._init = False
+            return
+
+        self.draw_data()
+        self.custom_ticks()
+
+        self.idle()
+        self._init = True
+
+    def draw_data(self):
+        # Plot data
+        x = list(map(lambda v: v[0], self.data.data))
+        y = list(map(lambda v: v[1], self.data.data))
+
+        self._line, = self.canvas.axes.plot(
+            x, y,
+            color=self.color_plot,
+            **self.plot_default_kargs
+        )
+
+    @timer
+    def update(self, ind=None):
+        if not self._init:
+            self.draw()
+            return
+
+        self.update_data()
+
+        self.update_idle()
+
+    def update_data(self):
+        x = list(map(lambda v: v[0], self.data.data))
+        y = list(map(lambda v: v[1], self.data.data))
+
+        self._line.set_data(x, y)

src/View/BoundaryConditionsAdisTS/Edit/Table.py

@@ -0,0 +1,121 @@
+# Table.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import logging
+import traceback
+
+from datetime import date, time, datetime, timedelta
+
+from tools import (
+    trace, timer,
+    timestamp_to_old_pamhyr_date,
+    old_pamhyr_date_to_timestamp
+)
+
+from View.Tools.PamhyrTable import PamhyrTableModel
+
+from PyQt5.QtCore import (
+    Qt, QVariant, QAbstractTableModel,
+    QCoreApplication, QModelIndex, pyqtSlot,
+    QRect, QTime, QDateTime,
+)
+
+from PyQt5.QtWidgets import (
+    QTableView, QAbstractItemView, QSpinBox,
+    QTimeEdit, QDateTimeEdit, QItemDelegate,
+)
+
+from View.BoundaryConditionsAdisTS.Edit.UndoCommand import (
+    AddCommand, DelCommand, SetDataCommand,
+)
+
+_translate = QCoreApplication.translate
+
+logger = logging.getLogger()
+
+
+class TableModel(PamhyrTableModel):
+    def data(self, index, role):
+        if role == Qt.TextAlignmentRole:
+            return Qt.AlignHCenter | Qt.AlignVCenter
+
+        if role != Qt.ItemDataRole.DisplayRole:
+            return QVariant()
+
+        row = index.row()
+        column = index.column()
+
+        value = QVariant()
+
+        if 0 <= column < 2:
+            v = self._data._data[row][column]
+            if self._data._types[column] == float:
+                value = f"{v:.4f}"
+            elif self._data.header[column] == "time":
+                if self._opt_data == "time":
+                    value = timestamp_to_old_pamhyr_date(int(v))
+                else:
+                    value = str(datetime.fromtimestamp(v))
+            else:
+                value = f"{v}"
+
+        return value
+
+    def setData(self, index, value, role=Qt.EditRole):
+        if not index.isValid() or role != Qt.EditRole:
+            return False
+
+        row = index.row()
+        column = index.column()
+
+        try:
+            self._undo.push(
+                SetDataCommand(
+                    self._data, row, column, value
+                )
+            )
+        except Exception as e:
+            logger.info(e)
+            logger.debug(traceback.format_exc())
+
+        self.dataChanged.emit(index, index)
+        return True
+
+    def add(self, row, parent=QModelIndex()):
+        self.beginInsertRows(parent, row, row - 1)
+
+        self._undo.push(
+            AddCommand(
+                self._data, row
+            )
+        )
+
+        self.endInsertRows()
+        self.layoutChanged.emit()
+
+    def delete(self, rows, parent=QModelIndex()):
+        self.beginRemoveRows(parent, rows[0], rows[-1])
+
+        self._undo.push(
+            DelCommand(
+                self._data, rows
+            )
+        )
+
+        self.endRemoveRows()
+

src/View/BoundaryConditionsAdisTS/Edit/UndoCommand.py

@@ -0,0 +1,95 @@
+# UndoCommand.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import logging
+
+from copy import deepcopy
+from tools import trace, timer
+
+from PyQt5.QtWidgets import (
+    QMessageBox, QUndoCommand, QUndoStack,
+)
+
+from Model.BoundaryConditionsAdisTS.BoundaryConditionAdisTS import BoundaryConditionAdisTS
+
+logger = logging.getLogger()
+
+
+class SetDataCommand(QUndoCommand):
+    def __init__(self, data, index, column, new_value):
+        QUndoCommand.__init__(self)
+
+        self._data = data
+        self._index = index
+        self._column = column
+        self._old = self._data._data[self._index][self._column]
+        _type = self._data._types[self._column]
+        self._new = _type(new_value)
+
+    def undo(self):
+        if self._column == 0:
+            self._data._data[self._index] = (self._old,self._data._data[self._index][1])
+        else:
+            self._data._data[self._index] = (self._data._data[self._index][0], self._old)
+
+    def redo(self):
+        if self._column == 0:
+            self._data._data[self._index] = (self._new,self._data._data[self._index][1])
+        else:
+            self._data._data[self._index] = (self._data._data[self._index][0], self._new)
+
+class AddCommand(QUndoCommand):
+    def __init__(self, data, index):
+        QUndoCommand.__init__(self)
+
+        self._data = data
+        self._index = index
+        self._new = None
+
+    def undo(self):
+        del self._data._data[self._index]
+
+    def redo(self):
+        if self._new is None:
+            self._new = self._data._data.insert(self._index, (self._data._types[0](0), self._data._types[1](0.0)))
+        else:
+            self._data._data.insert(self._index, self._new)
+
+class DelCommand(QUndoCommand):
+    def __init__(self, data, rows):
+        QUndoCommand.__init__(self)
+
+        self._data = data
+        self._rows = rows
+
+        self._bc = []
+        for row in rows:
+            self._bc.append((row, self._data._data[row]))
+        self._bc.sort()
+
+    def undo(self):
+        for row, el in self._bc:
+            self._data._data.insert(row, el)
+
+    def redo(self):
+        for row in self._rows:
+            del self._data._data[row]
+
+
+
+

src/View/BoundaryConditionsAdisTS/Edit/Window.py

@@ -0,0 +1,206 @@
+ # Window.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import logging
+
+from tools import timer, trace
+
+from View.Tools.PamhyrWindow import PamhyrWindow
+from View.Tools.PamhyrWidget import PamhyrWidget
+from View.Tools.PamhyrDelegate import PamhyrExTimeDelegate
+
+from PyQt5.QtGui import (
+    QKeySequence,
+)
+
+from PyQt5 import QtCore
+from PyQt5.QtCore import (
+    Qt, QVariant, QAbstractTableModel, QCoreApplication,
+    pyqtSlot, pyqtSignal,
+)
+
+from PyQt5.QtWidgets import (
+    QDialogButtonBox, QPushButton, QLineEdit,
+    QFileDialog, QTableView, QAbstractItemView,
+    QUndoStack, QShortcut, QAction, QItemDelegate,
+    QHeaderView, QDoubleSpinBox, QVBoxLayout,
+)
+
+from View.Tools.Plot.PamhyrCanvas import MplCanvas
+from View.Tools.Plot.PamhyrToolbar import PamhyrPlotToolbar
+
+from View.BoundaryConditionsAdisTS.Edit.translate import BCETranslate
+from View.BoundaryConditionsAdisTS.Edit.Table import TableModel
+from View.BoundaryConditionsAdisTS.Edit.Plot import Plot
+
+_translate = QCoreApplication.translate
+
+logger = logging.getLogger()
+
+class EditBoundaryConditionWindow(PamhyrWindow):
+    _pamhyr_ui = "EditBoundaryConditionsAdisTS"
+    _pamhyr_name = "Edit Boundary Conditions AdisTS"
+
+    def __init__(self, data=None, study=None, config=None, parent=None):
+        self._data = data
+        trad = BCETranslate()
+
+        name = trad[self._pamhyr_name]
+
+        super(EditBoundaryConditionWindow, self).__init__(
+            title=name,
+            study=study,
+            config=config,
+            trad=trad,
+            parent=parent
+        )
+
+        if self._data is not None:
+            n = self._data.node
+            node_name = next(filter(lambda x: x.id == n, self._study.river._nodes)).name
+            name += (
+                f" - {study.name} " +
+                f"({node_name})"
+            )
+
+        self._hash_data.append(data)
+
+        self.setup_table()
+        self.setup_plot()
+        self.setup_connections()
+
+    def setup_table(self):
+        if self._data.type == "Concentration":
+            self._data.header = ["time", "concentration"]
+        else:
+            self._data.header = ["time", "rate"]
+
+        headers = {}
+        table_headers = self._trad.get_dict("table_headers")
+        for h in self._data.header:
+            headers[h] = table_headers[h]
+
+        self._delegate_time = PamhyrExTimeDelegate(
+            data=self._data,
+            mode=self._study.time_system,
+            parent=self
+        )
+
+        table = self.find(QTableView, "tableView")
+        self._table = TableModel(
+            table_view=table,
+            table_headers=headers,
+            editable_headers=self._data.header,
+            delegates={
+                # "time": self._delegate_time,
+            },
+            data=self._data,
+            undo=self._undo_stack,
+            opt_data=self._study.time_system
+        )
+
+        table.setModel(self._table)
+        table.setSelectionBehavior(QAbstractItemView.SelectRows)
+        table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
+        table.setAlternatingRowColors(True)
+
+    def setup_plot(self):
+        self.canvas = MplCanvas(width=5, height=4, dpi=100)
+        self.canvas.setObjectName("canvas")
+        self.toolbar = PamhyrPlotToolbar(
+            self.canvas, self
+        )
+        self.verticalLayout.addWidget(self.toolbar)
+        self.verticalLayout.addWidget(self.canvas)
+
+        self.plot = Plot(
+            canvas=self.canvas,
+            data=self._data,
+            mode=self._study.time_system,
+            trad=self._trad,
+            toolbar=self.toolbar,
+        )
+        self.plot.draw()
+
+    def setup_connections(self):
+        self.find(QAction, "action_add").triggered.connect(self.add)
+        self.find(QAction, "action_del").triggered.connect(self.delete)
+
+        self._table.dataChanged.connect(self.update)
+
+    def update(self):
+        self.plot.update()
+
+    def index_selected_row(self):
+        table = self.find(QTableView, "tableView")
+        return table.selectionModel()\
+                    .selectedRows()[0]\
+                    .row()
+
+    def index_selected_rows(self):
+        table = self.find(QTableView, "tableView")
+        return list(
+            # Delete duplicate
+            set(
+                map(
+                    lambda i: i.row(),
+                    table.selectedIndexes()
+                )
+            )
+        )
+
+    def add(self):
+        rows = self.index_selected_rows()
+        if len(self._data) == 0 or len(rows) == 0:
+            self._table.add(0)
+        else:
+            self._table.add(rows[0])
+
+        self.plot.update()
+
+    def delete(self):
+        rows = self.index_selected_rows()
+        if len(rows) == 0:
+            return
+
+        self._table.delete(rows)
+        self.plot.update()
+
+    def sort(self):
+        self._table.sort(False)
+        self.plot.update()
+
+    def _copy(self):
+        rows = self.index_selected_rows()
+
+        table = []
+        table.append(self._data.header)
+
+        data = self._data.data
+        for row in rows:
+            table.append(list(data[row]))
+
+        self.copyTableIntoClipboard(table)
+
+    def _undo(self):
+        self._table.undo()
+        self.plot.update()
+
+    def _redo(self):
+        self._table.redo()
+        self.plot.update()

src/View/BoundaryConditionsAdisTS/Edit/translate.py

@@ -0,0 +1,41 @@
+# translate.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+from PyQt5.QtCore import QCoreApplication
+
+from View.Translate import MainTranslate
+
+from View.BoundaryCondition.translate import BCTranslate
+
+_translate = QCoreApplication.translate
+
+
+class BCETranslate(BCTranslate):
+    def __init__(self):
+        super(BCETranslate, self).__init__()
+
+        self._dict["Edit Boundary Conditions AdisTS"] = _translate(
+            "BoundaryConditionAdisTS", "Edit boundary conditions AdisTS"
+        )
+
+        self._sub_dict["table_headers"] = {
+            "time": self._dict["time"],
+            "date": self._dict["date"],
+            "rate": _translate("BoundaryConditionAdisTS", "Rate"),
+            "concentration": _translate("BoundaryConditionAdisTS", "Concentration"),
+        }

src/View/BoundaryConditionsAdisTS/Table.py

@@ -0,0 +1,206 @@
+# Table.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import logging
+import traceback
+
+from tools import trace, timer
+
+from PyQt5.QtCore import (
+    Qt, QVariant, QAbstractTableModel,
+    QCoreApplication, QModelIndex, pyqtSlot,
+    QRect,
+)
+
+from PyQt5.QtWidgets import (
+    QDialogButtonBox, QPushButton, QLineEdit,
+    QFileDialog, QTableView, QAbstractItemView,
+    QUndoStack, QShortcut, QAction, QItemDelegate,
+    QComboBox,
+)
+
+from Model.BoundaryCondition.BoundaryConditionTypes import (
+    NotDefined, PonctualContribution,
+    TimeOverZ, TimeOverDischarge, ZOverDischarge
+)
+
+from View.Tools.PamhyrTable import PamhyrTableModel
+
+from View.BoundaryConditionsAdisTS.UndoCommand import (
+    SetNodeCommand, SetTypeCommand,
+    AddCommand, DelCommand,
+)
+from View.BoundaryCondition.translate import BC_types
+
+logger = logging.getLogger()
+
+_translate = QCoreApplication.translate
+
+
+class ComboBoxDelegate(QItemDelegate):
+    def __init__(self, data=None, mode="type", tab="",
+                 trad=None, parent=None):
+        super(ComboBoxDelegate, self).__init__(parent)
+
+        self._data = data
+        self._mode = mode
+        self._tab = tab
+        self._trad = trad
+
+        self._long_types = {}
+        if self._trad is not None:
+            self._long_types = self._trad.get_dict("long_types")
+
+    def createEditor(self, parent, option, index):
+        self.editor = QComboBox(parent)
+
+        if self._mode == "type":
+            lst = [self._trad["not_associated"], "Concentration", "Rate"]
+            self.editor.addItems(
+                lst
+            )
+        else:
+            self.editor.addItems(
+                [self._trad["not_associated"]] +
+                self._data.nodes_names()
+            )
+
+        self.editor.setCurrentText(index.data(Qt.DisplayRole))
+        return self.editor
+
+    def setEditorData(self, editor, index):
+        value = index.data(Qt.DisplayRole)
+        self.editor.currentTextChanged.connect(self.currentItemChanged)
+
+    def setModelData(self, editor, model, index):
+        text = str(editor.currentText())
+        model.setData(index, text)
+        editor.close()
+        editor.deleteLater()
+
+    def updateEditorGeometry(self, editor, option, index):
+        r = QRect(option.rect)
+        if self.editor.windowFlags() & Qt.Popup:
+            if editor.parent() is not None:
+                r.setTopLeft(self.editor.parent().mapToGlobal(r.topLeft()))
+        editor.setGeometry(r)
+
+    @pyqtSlot()
+    def currentItemChanged(self):
+        self.commitData.emit(self.sender())
+
+
+class TableModel(PamhyrTableModel):
+    def __init__(self, pollutant=None, bc_list =None, trad=None, **kwargs):
+        self._trad = trad
+        self._bc_list = bc_list
+        self._pollutant = pollutant
+
+        super(TableModel, self).__init__(trad=trad, **kwargs)
+
+    def _setup_lst(self):
+        self._lst = self._bc_list.lst
+
+    def rowCount(self, parent):
+        return len(self._lst)
+
+    def data(self, index, role):
+        if len(self._lst) != 0:
+            data = list(filter(lambda x: x.pollutant == self._pollutant,
+                                     self._lst))
+        else:
+            data = []
+
+        if role != Qt.ItemDataRole.DisplayRole:
+            return QVariant()
+
+        row = index.row()
+        column = index.column()
+
+        if self._headers[column] == "type":
+            n = data[row].type
+            if n is None or n == "":
+                return self._trad["not_associated"]
+            return n
+        elif self._headers[column] == "node":
+            n = data[row].node
+            if n is None:
+                return self._trad["not_associated"]
+            return next(filter(lambda x: x.id == n, self._data._nodes)).name
+
+        return QVariant()
+
+    def setData(self, index, value, role=Qt.EditRole):
+        if not index.isValid() or role != Qt.EditRole:
+            return False
+
+        row = index.row()
+        column = index.column()
+
+        try:
+            if self._headers[column] == "type":
+                self._undo.push(
+                    SetTypeCommand(
+                        self._lst, row, value
+                    )
+                )
+            elif self._headers[column] == "node":
+                self._undo.push(
+                    SetNodeCommand(
+                        self._lst, row, self._data.node(value)
+                    )
+                )
+                print(value, self._data.node(value).id)
+        except Exception as e:
+            logger.info(e)
+            logger.debug(traceback.format_exc())
+
+        self.dataChanged.emit(index, index)
+        return True
+
+    def add(self, row, parent=QModelIndex()):
+        self.beginInsertRows(parent, row, row - 1)
+
+        self._undo.push(
+            AddCommand(
+                self._pollutant, self._bc_list, self._lst, row
+            )
+        )
+
+        self.endInsertRows()
+        self.layoutChanged.emit()
+
+    def delete(self, rows, parent=QModelIndex()):
+        self.beginRemoveRows(parent, rows[0], rows[-1])
+
+        self._undo.push(
+            DelCommand(
+                self._lst, rows
+            )
+        )
+
+        self.endRemoveRows()
+        self.layoutChanged.emit()
+
+    def undo(self):
+        self._undo.undo()
+        self.layoutChanged.emit()
+
+    def redo(self):
+        self._undo.redo()
+        self.layoutChanged.emit()

src/View/BoundaryConditionsAdisTS/UndoCommand.py

@@ -0,0 +1,99 @@
+# UndoCommand.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+from copy import deepcopy
+from tools import trace, timer
+
+from PyQt5.QtWidgets import (
+    QMessageBox, QUndoCommand, QUndoStack,
+)
+
+from Model.BoundaryConditionsAdisTS.BoundaryConditionAdisTS import BoundaryConditionAdisTS
+from Model.BoundaryConditionsAdisTS.BoundaryConditionsAdisTSList import BoundaryConditionsAdisTSList
+
+class SetNodeCommand(QUndoCommand):
+    def __init__(self, bcs, index, node):
+        QUndoCommand.__init__(self)
+
+        self._bcs = bcs
+        self._index = index
+        self._old = self._bcs[self._index].node
+        self._new = node.id
+
+    def undo(self):
+        self._bcs[self._index].node = self._old
+
+    def redo(self):
+        self._bcs[self._index].node = self._new
+
+class SetTypeCommand(QUndoCommand):
+    def __init__(self, bcs, index, _type):
+        QUndoCommand.__init__(self)
+
+        self._bcs = bcs
+        self._index = index
+        self._type = _type
+        self._old = self._bcs[self._index].type
+        self._new = self._type
+
+    def undo(self):
+        self._bcs[self._index].type = self._old
+
+    def redo(self):
+        self._bcs[self._index].type = self._new
+
+class AddCommand(QUndoCommand):
+    def __init__(self, pollutant, bcs_list, bcs, index):
+        QUndoCommand.__init__(self)
+
+        self._bcs = bcs
+        self._bc_list = bcs_list
+        self._pollutant = pollutant
+        self._index = index
+        self._new = None
+
+    def undo(self):
+        del self._bcs[self._index]
+
+    def redo(self):
+        if self._new is None:
+            self._new = self._bc_list.new(self._index, self._pollutant)
+        else:
+            self._bcs.insert(self._index, self._new)
+
+
+class DelCommand(QUndoCommand):
+    def __init__(self, bcs, rows):
+        QUndoCommand.__init__(self)
+
+        self._bcs = bcs
+        self._rows = rows
+
+        self._bc = []
+        for row in rows:
+            self._bc.append((row, self._bcs[row]))
+        self._bc.sort()
+
+    def undo(self):
+        for row, el in self._bc:
+            self._bcs.insert(row, el)
+
+    def redo(self):
+        for row in self._rows:
+            del self._bcs[row]
+

src/View/BoundaryConditionsAdisTS/Window.py

@@ -0,0 +1,195 @@
+# Window.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import logging
+
+from tools import trace, timer, logger_exception
+
+from View.Tools.PamhyrWindow import PamhyrWindow
+
+from PyQt5.QtGui import (
+    QKeySequence,
+)
+
+from PyQt5.QtCore import (
+    Qt, QVariant, QAbstractTableModel,
+    QCoreApplication, QModelIndex, pyqtSlot,
+    QRect,
+)
+
+from PyQt5.QtWidgets import (
+    QDialogButtonBox, QPushButton, QLineEdit,
+    QFileDialog, QTableView, QAbstractItemView,
+    QUndoStack, QShortcut, QAction, QItemDelegate,
+    QComboBox, QVBoxLayout, QHeaderView, QTabWidget,
+    QWidget,
+)
+
+from View.BoundaryConditionsAdisTS.Table import (
+    TableModel, ComboBoxDelegate
+)
+
+from View.Network.GraphWidget import GraphWidget
+from View.BoundaryConditionsAdisTS.translate import BCAdisTSTranslate
+from View.BoundaryConditionsAdisTS.Edit.Window import EditBoundaryConditionWindow
+
+_translate = QCoreApplication.translate
+
+logger = logging.getLogger()
+
+
+class BoundaryConditionAdisTSWindow(PamhyrWindow):
+    _pamhyr_ui = "BoundaryConditionsAdisTS"
+    _pamhyr_name = "Boundary conditions AdisTS"
+
+    def __init__(self, pollutant=None, study=None, config=None, parent=None):
+        trad = BCAdisTSTranslate()
+        name = (
+            trad[self._pamhyr_name] +
+            " - " + study.name
+        )
+
+        self._pollutant = pollutant
+
+        super(BoundaryConditionAdisTSWindow, self).__init__(
+            title=name,
+            study=study,
+            config=config,
+            trad=trad,
+            parent=parent
+        )
+
+        self._bcs = self._study.river.boundary_conditions_adists
+
+        self.setup_table()
+        self.setup_graph()
+        self.setup_connections()
+
+        self.ui.setWindowTitle(self._title)
+
+    def setup_table(self):
+        self._delegate_type = ComboBoxDelegate(
+            trad=self._trad,
+            data=self._study.river,
+            mode="type",
+            parent=self
+        )
+        self._delegate_node = ComboBoxDelegate(
+            trad=self._trad,
+            data=self._study.river,
+            mode="node",
+            parent=self
+        )
+
+        table = self.find(QTableView, f"tableView")
+        self._table = TableModel(
+            table_view=table,
+            table_headers=self._trad.get_dict("table_headers"),
+            editable_headers=["type", "node"],
+            delegates={
+                "type": self._delegate_type,
+                "node": self._delegate_node,
+            },
+            trad=self._trad,
+            bc_list = self._study.river.boundary_conditions_adists,
+            undo=self._undo_stack,
+            pollutant=self._pollutant,
+            data=self._study.river
+        )
+        table.setModel(self._table)
+        table.setSelectionBehavior(QAbstractItemView.SelectRows)
+        table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
+        table.setAlternatingRowColors(True)
+
+    def setup_graph(self):
+        self.graph_widget = GraphWidget(
+            self._study.river,
+            min_size=None, size=(200, 200),
+            only_display=True,
+            parent=self
+        )
+        self.graph_layout = self.find(QVBoxLayout, "verticalLayout")
+        self.graph_layout.addWidget(self.graph_widget)
+
+    def setup_connections(self):
+        self.find(QAction, "action_add").triggered.connect(self.add)
+        self.find(QAction, "action_del").triggered.connect(self.delete)
+        self.find(QAction, "action_edit").triggered.connect(self.edit)
+
+    def index_selected_row(self):
+        tab = "liquid"
+        table = self.find(QTableView, f"tableView_{tab}")
+        return table.selectionModel()\
+                    .selectedRows()[0]\
+                    .row()
+
+    def index_selected_rows(self):
+        table = self.find(QTableView, f"tableView")
+        return list(
+            # Delete duplicate
+            set(
+                map(
+                    lambda i: i.row(),
+                    table.selectedIndexes()
+                )
+            )
+        )
+
+    def add(self):
+        rows = self.index_selected_rows()
+        if len(self._bcs) == 0 or len(rows) == 0:
+            self._table.add(0)
+        else:
+            self._table.add(rows[0])
+
+    def delete(self):
+        rows = self.index_selected_rows()
+        if len(rows) == 0:
+            return
+
+        self._table.delete(rows)
+
+    def _copy(self):
+        logger.info("TODO: copy")
+
+    def _paste(self):
+        logger.info("TODO: paste")
+
+    def _undo(self):
+        self._table.undo()
+
+    def _redo(self):
+        self._table.redo()
+
+    def edit(self):
+        rows = self.index_selected_rows()
+        for row in rows:
+            data = self._bcs.lst[row]
+
+            if self.sub_window_exists(
+                EditBoundaryConditionWindow,
+                data=[self._study, None, data]
+            ):
+                continue
+
+            win = EditBoundaryConditionWindow(
+                data=data,
+                study=self._study,
+                parent=self
+            )
+            win.show()

src/View/BoundaryConditionsAdisTS/translate.py

@@ -0,0 +1,36 @@
+# translate.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+from PyQt5.QtCore import QCoreApplication
+
+from View.Translate import MainTranslate
+
+_translate = QCoreApplication.translate
+
+class BCAdisTSTranslate(MainTranslate):
+    def __init__(self):
+        super(BCAdisTSTranslate, self).__init__()
+
+        self._dict["Boundary conditions AdisTS"] = _translate(
+            "BoundaryConditionsAdisTS", "Boundary conditions AdisTS"
+        )
+
+        self._sub_dict["table_headers"] = {
+            "type": self._dict["type"],
+            "node": _translate("BoundaryCondition", "Node")
+        }

src/View/CheckList/WindowAdisTS.py

@@ -0,0 +1,200 @@
+# WindowAdisTS.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+from tools import trace, timer
+
+from View.Tools.PamhyrWindow import PamhyrWindow
+
+from PyQt5.QtGui import (
+    QKeySequence,
+)
+
+from PyQt5.QtCore import (
+    Qt, QVariant, QAbstractTableModel,
+    QCoreApplication, QModelIndex, QRect, QThread,
+    pyqtSlot, pyqtSignal,
+)
+
+from PyQt5.QtWidgets import (
+    QDialogButtonBox, QPushButton, QLineEdit,
+    QFileDialog, QTableView, QAbstractItemView,
+    QUndoStack, QShortcut, QAction, QItemDelegate,
+    QComboBox, QVBoxLayout, QHeaderView, QTabWidget,
+    QProgressBar, QLabel,
+)
+
+from View.CheckList.Table import TableModel
+from View.CheckList.Worker import Worker
+from View.CheckList.Translate import CheckListTranslate
+
+_translate = QCoreApplication.translate
+
+
+class CheckListWindowAdisTS(PamhyrWindow):
+    _pamhyr_ui = "CheckList"
+    _pamhyr_name = "Check list"
+
+    signalStatus = pyqtSignal(str)
+
+    def __init__(self, autorun: bool = True,
+                 study=None, config=None,
+                 solver=None, parent=None, mage_rep=None):
+        trad = CheckListTranslate()
+
+        self._autorun = autorun
+        self._solver = solver
+        self._mage_rep = mage_rep
+
+        name = trad[self._pamhyr_name] + " - " + study.name
+
+        super(CheckListWindowAdisTS, self).__init__(
+            title=name,
+            study=study,
+            config=config,
+            trad=trad,
+            options=[],
+            parent=parent
+        )
+
+        # Add solver to hash computation data
+        self._hash_data.append(self._solver)
+
+        self._checker_list = (
+            self._study.checkers() +
+            self._solver.checkers()
+        )
+
+        self.setup_table()
+        self.setup_progress_bar()
+        self.setup_connections()
+        self.setup_thread()
+        self.setup_statusbar()
+
+    def setup_table(self):
+        table = self.find(QTableView, f"tableView")
+        self._table = TableModel(
+            table_view=table,
+            table_headers=self._trad.get_dict("table_headers"),
+            data=self._checker_list,
+        )
+
+    def setup_progress_bar(self):
+        self._progress = self.find(QProgressBar, f"progressBar")
+        self._p = 0             # Progress current step
+
+        self._progress.setRange(0, len(self._checker_list))
+        self._progress.setValue(self._p)
+
+    def setup_connections(self):
+        self.find(QPushButton, "pushButton_ok").clicked.connect(self.accept)
+        self.find(QPushButton, "pushButton_retry").clicked.connect(self.retry)
+        self.find(QPushButton, "pushButton_cancel")\
+            .clicked.connect(self.reject)
+
+    def setup_thread(self):
+        self._worker = Worker(self._study, self._checker_list)
+        self._worker_thread = QThread()
+        self._worker.moveToThread(self._worker_thread)
+
+        # Connect any worker signals
+        self._worker.signalStatus.connect(self.update)
+        self._worker_thread.started.connect(self._worker.process)
+
+        self._worker_thread.start()
+
+    def retry(self):
+        self._worker_thread.terminate()
+        self._worker_thread.wait()
+
+        self.find(QPushButton, "pushButton_retry").setEnabled(False)
+        self.find(QPushButton, "pushButton_ok").setEnabled(False)
+
+        self.setup_thread()
+
+    def _compute_status(self):
+        ok = len(list(filter(lambda c: c.is_ok(), self._checker_list)))
+        warning = len(
+            list(filter(lambda c: c.is_warning(), self._checker_list)))
+        error = len(list(filter(lambda c: c.is_error(), self._checker_list)))
+
+        return ok, warning, error
+
+    def _compute_status_label(self):
+        ok, warning, error = self._compute_status()
+        return (f"<font color=\"Green\">Ok: {ok} </font> |" +
+                f"<font color=\"Orange\">Warning: {warning} </font> |" +
+                f"<font color=\"Red\">Error: {error}</font>")
+
+    def setup_statusbar(self):
+        txt = self._compute_status_label()
+        self._status_label = QLabel(txt)
+        self.statusbar.addPermanentWidget(self._status_label)
+
+    def update_statusbar(self):
+        txt = self._compute_status_label()
+        self._status_label.setText(txt)
+
+    def progress(self):
+        self._p += 1
+        self._progress.setValue(self._p)
+        self._table.update()
+
+    def start_compute(self):
+        self._p = 0
+        self._progress.setValue(self._p)
+
+    def info_compute(self, str):
+        self.statusbar.showMessage(str, 3000)
+
+    def end_compute(self):
+        self._table.layoutChanged.emit()
+        self.find(QPushButton, "pushButton_retry").setEnabled(True)
+
+        errors = any(filter(lambda c: c.is_error(), self._checker_list))
+        if not errors:
+            self.find(QPushButton, "pushButton_ok").setEnabled(True)
+            if self._autorun:
+                self._parent.solver_log_adists(self._solver, self._mage_rep)
+                self.end()
+
+        self.update_statusbar()
+
+    def update(self, key: str):
+        if key == "start":
+            self.start_compute()
+            self.info_compute("Starting ...")
+        elif key == "end":
+            self.info_compute("Finish")
+            self.end_compute()
+        elif key == "progress":
+            self.progress()
+        else:
+            self.info_compute(key)
+
+        self.update_statusbar()
+
+    def end(self):
+        # self._worker.join()b
+        self.close()
+
+    def reject(self):
+        self.end()
+
+    def accept(self):
+        self._parent.solver_log_adists(self._solver, self._mage_rep)
+        # self.end()

src/View/D90AdisTS/Table.py

@@ -0,0 +1,217 @@
+# Table.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import logging
+import traceback
+from tools import trace, timer
+
+from PyQt5.QtCore import (
+    Qt, QVariant, QAbstractTableModel,
+    QCoreApplication, QModelIndex, pyqtSlot,
+    QRect,
+)
+
+from PyQt5.QtWidgets import (
+    QDialogButtonBox, QPushButton, QLineEdit,
+    QFileDialog, QTableView, QAbstractItemView,
+    QUndoStack, QShortcut, QAction, QItemDelegate,
+    QComboBox,
+)
+
+from View.Tools.PamhyrTable import PamhyrTableModel
+
+from View.D90AdisTS.UndoCommand import (
+    SetCommand, AddCommand, SetCommandSpec,
+    DelCommand,
+)
+
+logger = logging.getLogger()
+
+_translate = QCoreApplication.translate
+
+
+class ComboBoxDelegate(QItemDelegate):
+    def __init__(self, data=None, ic_spec_lst=None, trad=None, parent=None, mode="reaches"):
+        super(ComboBoxDelegate, self).__init__(parent)
+
+        self._data = data
+        self._mode = mode
+        self._trad = trad
+        self._ic_spec_lst = ic_spec_lst
+
+    def createEditor(self, parent, option, index):
+        self.editor = QComboBox(parent)
+
+        val = []
+        if self._mode == "kp":
+            reach_id = self._ic_spec_lst[index.row()].reach
+
+            reach = next(filter(lambda edge: edge.id == reach_id, self._data.edges()))
+
+            if reach_id is not None:
+                val = list(
+                    map(
+                        lambda kp: str(kp), reach.reach.get_kp()
+                    )
+                )
+        else:
+            val = list(
+                map(
+                    lambda n: n.name, self._data.edges()
+                )
+            )
+
+        self.editor.addItems(
+            [self._trad['not_associated']] +
+            val
+        )
+
+        self.editor.setCurrentText(str(index.data(Qt.DisplayRole)))
+        return self.editor
+
+    def setEditorData(self, editor, index):
+        value = index.data(Qt.DisplayRole)
+        self.editor.currentTextChanged.connect(self.currentItemChanged)
+
+    def setModelData(self, editor, model, index):
+        text = str(editor.currentText())
+        model.setData(index, text)
+        editor.close()
+        editor.deleteLater()
+
+    def updateEditorGeometry(self, editor, option, index):
+        r = QRect(option.rect)
+        if self.editor.windowFlags() & Qt.Popup:
+            if editor.parent() is not None:
+                r.setTopLeft(self.editor.parent().mapToGlobal(r.topLeft()))
+        editor.setGeometry(r)
+
+    @pyqtSlot()
+    def currentItemChanged(self):
+        self.commitData.emit(self.sender())
+
+
+class D90TableModel(PamhyrTableModel):
+    def __init__(self, river=None, data=None, **kwargs):
+        self._river = river
+
+        super(D90TableModel, self).__init__(data=data, **kwargs)
+
+        self._data = data
+
+    def _setup_lst(self):
+        self._lst = self._data._data
+
+    def rowCount(self, parent):
+        return len(self._lst)
+
+    def data(self, index, role):
+        if role != Qt.ItemDataRole.DisplayRole:
+            return QVariant()
+
+        row = index.row()
+        column = index.column()
+
+        if self._headers[column] is "name":
+            n = self._lst[row].name
+            if n is None or n == "":
+                return self._trad['not_associated']
+            return n
+        elif self._headers[column] is "reach":
+            n = self._lst[row].reach
+            if n is None:
+                return self._trad['not_associated']
+            return next(filter(lambda edge: edge.id == n, self._river.edges())).name
+        elif self._headers[column] is "start_kp":
+            n = self._lst[row].start_kp
+            if n is None:
+                return self._trad['not_associated']
+            return n
+        elif self._headers[column] is "end_kp":
+            n = self._lst[row].end_kp
+            if n is None:
+                return self._trad['not_associated']
+            return n
+        elif self._headers[column] is "d90":
+            n = self._lst[row].d90
+            if n is None:
+                return self._trad['not_associated']
+            return n
+
+        return QVariant()
+
+    def setData(self, index, value, role=Qt.EditRole):
+        if not index.isValid() or role != Qt.EditRole:
+            return False
+
+        row = index.row()
+        column = index.column()
+
+        try:
+            if self._headers[column] != "reach":
+                self._undo.push(
+                    SetCommandSpec(
+                        self._lst, row, self._headers[column], value
+                    )
+                )
+            elif self._headers[column] == "reach":
+                print(self._river.edge(value).id)
+                self._undo.push(
+                    SetCommandSpec(
+                        self._lst, row, self._headers[column], self._river.edge(value).id
+                    )
+                )
+        except Exception as e:
+            logger.info(e)
+            logger.debug(traceback.format_exc())
+
+        self.dataChanged.emit(index, index)
+        return True
+
+    def add(self, row, parent=QModelIndex()):
+        self.beginInsertRows(parent, row, row - 1)
+
+        self._undo.push(
+            AddCommand(
+                self._data, self._lst, row
+            )
+        )
+
+        self.endInsertRows()
+        self.layoutChanged.emit()
+
+    def delete(self, rows, parent=QModelIndex()):
+        self.beginRemoveRows(parent, rows[0], rows[-1])
+
+        self._undo.push(
+            DelCommand(
+                self._data, self._lst, rows
+            )
+        )
+
+        self.endRemoveRows()
+        self.layoutChanged.emit()
+
+    def undo(self):
+        self._undo.undo()
+        self.layoutChanged.emit()
+
+    def redo(self):
+        self._undo.redo()
+        self.layoutChanged.emit()
+

src/View/D90AdisTS/TableDefault.py

@@ -0,0 +1,95 @@
+# Table.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import logging
+import traceback
+from tools import trace, timer
+
+from PyQt5.QtCore import (
+    Qt, QVariant, QAbstractTableModel,
+    QCoreApplication, QModelIndex, pyqtSlot,
+    QRect,
+)
+
+from PyQt5.QtWidgets import (
+    QDialogButtonBox, QPushButton, QLineEdit,
+    QFileDialog, QTableView, QAbstractItemView,
+    QUndoStack, QShortcut, QAction, QItemDelegate,
+    QComboBox,
+)
+
+from View.Tools.PamhyrTable import PamhyrTableModel
+
+from View.D90AdisTS.UndoCommand import (
+    SetCommand,
+)
+
+logger = logging.getLogger()
+
+_translate = QCoreApplication.translate
+
+class D90TableDefaultModel(PamhyrTableModel):
+    def __init__(self, **kwargs):
+        super(D90TableDefaultModel, self).__init__(**kwargs)
+
+    def data(self, index, role):
+        if role != Qt.ItemDataRole.DisplayRole:
+            return QVariant()
+
+        row = index.row()
+        column = index.column()
+
+        if self._headers[column] is "name":
+            return self._data[row].name
+        elif self._headers[column] is "d90":
+            n = self._data[row].d90
+            if n is None:
+                return self._trad['not_associated']
+            return n
+
+        return QVariant()
+
+    def setData(self, index, value, role=Qt.EditRole):
+        if not index.isValid() or role != Qt.EditRole:
+            return False
+
+        row = index.row()
+        column = index.column()
+
+        try:
+            if self._headers[column] is not None:
+                self._undo.push(
+                    SetCommand(
+                        self._data, row, self._headers[column], value
+                    )
+                )
+        except Exception as e:
+            logger.info(e)
+            logger.debug(traceback.format_exc())
+
+        self.dataChanged.emit(index, index)
+        return True
+
+    def undo(self):
+        self._undo.undo()
+        self.layoutChanged.emit()
+
+    def redo(self):
+        self._undo.redo()
+        self.layoutChanged.emit()
+

src/View/D90AdisTS/UndoCommand.py

@@ -0,0 +1,150 @@
+# UndoCommand.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+from copy import deepcopy
+from tools import trace, timer
+
+from PyQt5.QtWidgets import (
+    QMessageBox, QUndoCommand, QUndoStack,
+)
+
+from Model.D90AdisTS.D90AdisTS import D90AdisTS
+from Model.D90AdisTS.D90AdisTSList import D90AdisTSList
+
+
+class SetCommand(QUndoCommand):
+    def __init__(self, data, row, column, new_value):
+        QUndoCommand.__init__(self)
+
+        self._data = data
+        self._row = row
+        self._column = column
+
+        if self._column == "name":
+            self._old = self._data[self._row].name
+        elif self._column == "d90":
+            self._old = self._data[self._row].d90
+
+        _type = float
+        if column == "name":
+            _type = str
+
+        self._new = _type(new_value)
+
+    def undo(self):
+        if self._column == "name":
+            self._data[self._row].name = self._old
+        elif self._column == "d90":
+            self._data[self._row].d90 = self._old
+
+    def redo(self):
+        if self._column == "name":
+            self._data[self._row].name = self._new
+        elif self._column == "d90":
+            self._data[self._row].d90 = self._new
+
+class SetCommandSpec(QUndoCommand):
+    def __init__(self, data, row, column, new_value):
+        QUndoCommand.__init__(self)
+
+        self._data = data
+        self._row = row
+        self._column = column
+
+        if self._column == "name":
+            self._old = self._data[self._row].name
+        elif self._column == "reach":
+            self._old = self._data[self._row].reach
+        elif self._column == "start_kp":
+            self._old = self._data[self._row].start_kp
+        elif self._column == "end_kp":
+            self._old = self._data[self._row].end_kp
+        elif self._column == "d90":
+            self._old = self._data[self._row].d90
+
+        _type = float
+        if column == "name":
+            _type = str
+        elif column == "reach":
+            _type = int
+
+        self._new = _type(new_value)
+
+    def undo(self):
+        if self._column == "name":
+            self._data[self._row].name = self._old
+        elif self._column == "reach":
+            self._data[self._row].reach = self._old
+        elif self._column == "start_kp":
+            self._data[self._row].start_kp = self._old
+        elif self._column == "end_kp":
+            self._data[self._row].end_kp = self._old
+        elif self._column == "d90":
+            self._data[self._row].d90 = self._old
+
+    def redo(self):
+        if self._column == "name":
+            self._data[self._row].name = self._new
+        elif self._column == "reach":
+            self._data[self._row].reach = self._new
+        elif self._column == "start_kp":
+            self._data[self._row].start_kp = self._new
+        elif self._column == "end_kp":
+            self._data[self._row].end_kp = self._new
+        elif self._column == "d90":
+            self._data[self._row].d90 = self._new
+
+class AddCommand(QUndoCommand):
+    def __init__(self, data, ics_spec, index):
+        QUndoCommand.__init__(self)
+
+        self._data = data
+        self._ics_spec = ics_spec
+        self._index = index
+        self._new = None
+
+    def undo(self):
+        self._data.delete_i([self._index])
+
+    def redo(self):
+        if self._new is None:
+            self._new = self._data.new(self._index)
+        else:
+            self._data.insert(self._index, self._new)
+
+class DelCommand(QUndoCommand):
+    def __init__(self, data, ics_spec, rows):
+        QUndoCommand.__init__(self)
+
+        self._data = data
+        self._ics_spec = ics_spec
+        self._rows = rows
+        #self._data = data
+
+        self._ic = []
+        for row in rows:
+            self._ic.append((row, self._ics_spec[row]))
+        self._ic.sort()
+
+    def undo(self):
+        for row, el in self._ic:
+            self._data.insert(row, el)
+
+    def redo(self):
+        self._data.delete_i(self._rows)
+

src/View/D90AdisTS/Window.py

@@ -0,0 +1,283 @@
+# Window.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import os
+import logging
+
+from tools import trace, timer, logger_exception
+
+from View.Tools.PamhyrWindow import PamhyrWindow
+
+from PyQt5.QtGui import (
+    QKeySequence, QIcon,
+)
+
+from PyQt5.QtCore import (
+    Qt, QVariant, QAbstractTableModel,
+    QCoreApplication, QModelIndex, pyqtSlot,
+    QRect, QItemSelectionModel,
+)
+
+from PyQt5.QtWidgets import (
+    QDialogButtonBox, QPushButton, QLineEdit,
+    QFileDialog, QTableView, QAbstractItemView,
+    QUndoStack, QShortcut, QAction, QItemDelegate,
+    QComboBox, QVBoxLayout, QHeaderView, QTabWidget,
+    QVBoxLayout, QToolBar, QAction, QToolButton,
+)
+
+from Modules import Modules
+
+from View.InitialConditionsAdisTS.UndoCommand import (
+    SetCommand,
+)
+
+from View.D90AdisTS.TableDefault import (
+    D90TableDefaultModel,
+)
+
+from View.D90AdisTS.Table import (
+    D90TableModel, ComboBoxDelegate,
+)
+
+from View.D90AdisTS.translate import D90AdisTSTranslate
+
+from Solver.Mage import Mage8
+
+_translate = QCoreApplication.translate
+
+logger = logging.getLogger()
+
+
+class D90AdisTSWindow(PamhyrWindow):
+    _pamhyr_ui = "D90AdisTS"
+    _pamhyr_name = "D90 AdisTS"
+
+    def __init__(self, data=None, study=None, config=None, parent=None):
+        self._data = []
+        self._data.append(data)
+        trad = D90AdisTSTranslate()
+
+        name = (
+            trad[self._pamhyr_name] +
+            " - " + study.name +
+            " - " + self._data[0].name
+        )
+
+        super(D90AdisTSWindow, self).__init__(
+            title=name,
+            study=study,
+            config=config,
+            trad=trad,
+            parent=parent
+        )
+
+        self._hash_data.append(data)
+
+        self._d90_adists_lst = study.river.d90_adists
+
+        self.setup_table()
+
+        self.ui.setWindowTitle(self._title)
+
+    def setup_table(self):
+
+        path_icons = os.path.join(self._get_ui_directory(), f"ressources")
+
+        table_default = self.find(QTableView, f"tableView")
+
+        self._table = D90TableDefaultModel(
+            table_view=table_default,
+            table_headers=self._trad.get_dict("table_headers"),
+            editable_headers=["name", "d90"],
+            delegates={},
+            data=self._data,
+            undo=self._undo_stack,
+            trad=self._trad
+        )
+
+        table_default.setModel(self._table)
+        table_default.setSelectionBehavior(QAbstractItemView.SelectRows)
+        table_default.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
+        table_default.setAlternatingRowColors(True)
+
+        layout = self.find(QVBoxLayout, f"verticalLayout_1")
+        toolBar = QToolBar()
+        layout.addWidget(toolBar)
+
+        action_add = QAction(self)
+        action_add.setIcon(QIcon(os.path.join(path_icons, f"add.png")))
+        action_add.triggered.connect(self.add)
+        action_delete = QAction(self)
+        action_delete.setIcon(QIcon(os.path.join(path_icons, f"del.png")))
+        action_delete.triggered.connect(self.delete)
+
+        toolBar.addAction(action_add)
+        toolBar.addAction(action_delete)
+
+        self.table_spec = QTableView()
+        layout.addWidget(self.table_spec)
+
+        self._delegate_reach = ComboBoxDelegate(
+            trad=self._trad,
+            data=self._study.river,
+            ic_spec_lst=self._data[0]._data,
+            parent=self,
+            mode="reaches"
+        )
+        self._delegate_kp = ComboBoxDelegate(
+            trad=self._trad,
+            data=self._study.river,
+            ic_spec_lst=self._data[0]._data,
+            parent=self,
+            mode="kp"
+        )
+
+        self._table_spec = D90TableModel(
+            table_view=self.table_spec,
+            table_headers=self._trad.get_dict("table_headers_spec"),
+            editable_headers=["name", "reach", "start_kp", "end_kp", "d90"],
+            delegates={
+                "reach": self._delegate_reach,
+                "start_kp": self._delegate_kp,
+                "end_kp": self._delegate_kp
+            },
+            data=self._data[0],
+            undo=self._undo_stack,
+            trad=self._trad,
+            river=self._study.river
+        )
+
+        self.table_spec.setModel(self._table_spec)
+        self.table_spec.setSelectionBehavior(QAbstractItemView.SelectRows)
+        self.table_spec.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
+        self.table_spec.setAlternatingRowColors(True)
+
+        selectionModel = self.table_spec.selectionModel()
+        index = self.table_spec.model().index(0, 0)
+
+        selectionModel.select(
+            index,
+            QItemSelectionModel.Rows |
+            QItemSelectionModel.ClearAndSelect |
+            QItemSelectionModel.Select
+        )
+        self.table_spec.scrollTo(index)
+
+    def index_selected_row(self):
+        #table = self.find(QTableView, f"tableView")
+        table = self.table_spec
+        rows = table.selectionModel()\
+                    .selectedRows()
+
+        if len(rows) == 0:
+            return 0
+
+        return rows[0].row()
+
+    def index_selected_rows(self):
+        #table = self.find(QTableView, f"tableView")
+        table = self.table_spec
+        return list(
+            # Delete duplicate
+            set(
+                map(
+                    lambda i: i.row(),
+                    table.selectedIndexes()
+                )
+            )
+        )
+
+    def move_up(self):
+        row = self.index_selected_row()
+        self._table.move_up(row)
+        self._update()
+
+    def move_down(self):
+        row = self.index_selected_row()
+        self._table.move_down(row)
+        self._update()
+
+    def _copy(self):
+        rows = list(
+            map(
+                lambda row: row.row(),
+                self.tableView.selectionModel().selectedRows()
+            )
+        )
+
+        table = list(
+            map(
+                lambda eic: list(
+                    map(
+                        lambda k: eic[1][k],
+                        ["kp", "discharge", "elevation"]
+                    )
+                ),
+                filter(
+                    lambda eic: eic[0] in rows,
+                    enumerate(self._ics.lst())
+                )
+            )
+        )
+
+        self.copyTableIntoClipboard(table)
+
+    def _paste(self):
+        header, data = self.parseClipboardTable()
+
+        if len(data) + len(header) == 0:
+            return
+
+        logger.debug(
+            "D90: Paste: " +
+            f"header = {header}, " +
+            f"data = {data}"
+        )
+
+        try:
+            row = self.index_selected_row()
+            # self._table.paste(row, header, data)
+            self._table.paste(row, [], data)
+        except Exception as e:
+            logger_exception(e)
+
+        self._update()
+
+    def _undo(self):
+        self._table.undo()
+        self._update()
+
+    def _redo(self):
+        self._table.redo()
+        self._update()
+
+    def add(self):
+        rows = self.index_selected_rows()
+        if len(self._data[0]._data) == 0 or len(rows) == 0:
+            self._table_spec.add(0)
+        else:
+            self._table_spec.add(rows[0])
+
+    def delete(self):
+        print("del")
+        rows = self.index_selected_rows()
+        if len(rows) == 0:
+            print("len 0")
+            return
+        self._table_spec.delete(rows)

src/View/D90AdisTS/translate.py

@@ -0,0 +1,46 @@
+# translate.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+from PyQt5.QtCore import QCoreApplication
+
+from View.Translate import MainTranslate
+
+_translate = QCoreApplication.translate
+
+
+class D90AdisTSTranslate(MainTranslate):
+    def __init__(self):
+        super(D90AdisTSTranslate, self).__init__()
+
+        self._dict["D90 AdisTS"] = _translate(
+            "D90AdisTS", "D90 AdisTS")
+
+        self._dict["kp"] = self._dict["unit_kp"]
+
+        self._sub_dict["table_headers"] = {
+            "name": self._dict["name"],
+            "d90": _translate("Unit", "D90"),
+        }
+
+        self._sub_dict["table_headers_spec"] = {
+            "name": self._dict["name"],
+            "reach": self._dict["reach"],
+            "start_kp": _translate("Unit", "Start_KP (m)"),
+            "end_kp": _translate("Unit", "End_KP (m)"),
+            "d90": _translate("Unit", "D90"),
+        }

src/View/DIFAdisTS/Table.py

@@ -0,0 +1,229 @@
+# Table.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import logging
+import traceback
+from tools import trace, timer
+
+from PyQt5.QtCore import (
+    Qt, QVariant, QAbstractTableModel,
+    QCoreApplication, QModelIndex, pyqtSlot,
+    QRect,
+)
+
+from PyQt5.QtWidgets import (
+    QDialogButtonBox, QPushButton, QLineEdit,
+    QFileDialog, QTableView, QAbstractItemView,
+    QUndoStack, QShortcut, QAction, QItemDelegate,
+    QComboBox,
+)
+
+from View.Tools.PamhyrTable import PamhyrTableModel
+
+from View.DIFAdisTS.UndoCommand import (
+    SetCommand, AddCommand, SetCommandSpec,
+    DelCommand,
+)
+
+logger = logging.getLogger()
+
+_translate = QCoreApplication.translate
+
+
+class ComboBoxDelegate(QItemDelegate):
+    def __init__(self, data=None, ic_spec_lst=None, trad=None, parent=None, mode="reaches"):
+        super(ComboBoxDelegate, self).__init__(parent)
+
+        self._data = data
+        self._mode = mode
+        self._trad = trad
+        self._ic_spec_lst = ic_spec_lst
+
+    def createEditor(self, parent, option, index):
+        self.editor = QComboBox(parent)
+
+        val = []
+        if self._mode == "kp":
+            reach_id = self._ic_spec_lst[index.row()].reach
+
+            reach = next(filter(lambda edge: edge.id == reach_id, self._data.edges()))
+
+            if reach_id is not None:
+                val = list(
+                    map(
+                        lambda kp: str(kp), reach.reach.get_kp()
+                    )
+                )
+        elif self._mode == "method":
+            val = self._data.dif_adists.lst[0].types
+        else:
+            val = list(
+                map(
+                    lambda n: n.name, self._data.edges()
+                )
+            )
+
+        self.editor.addItems(
+            [self._trad['not_associated']] +
+            val
+        )
+
+        self.editor.setCurrentText(str(index.data(Qt.DisplayRole)))
+        return self.editor
+
+    def setEditorData(self, editor, index):
+        value = index.data(Qt.DisplayRole)
+        self.editor.currentTextChanged.connect(self.currentItemChanged)
+
+    def setModelData(self, editor, model, index):
+        text = str(editor.currentText())
+        model.setData(index, text)
+        editor.close()
+        editor.deleteLater()
+
+    def updateEditorGeometry(self, editor, option, index):
+        r = QRect(option.rect)
+        if self.editor.windowFlags() & Qt.Popup:
+            if editor.parent() is not None:
+                r.setTopLeft(self.editor.parent().mapToGlobal(r.topLeft()))
+        editor.setGeometry(r)
+
+    @pyqtSlot()
+    def currentItemChanged(self):
+        self.commitData.emit(self.sender())
+
+
+class DIFTableModel(PamhyrTableModel):
+    def __init__(self, river=None, data=None, **kwargs):
+        self._river = river
+
+        super(DIFTableModel, self).__init__(data=data, **kwargs)
+
+        self._data = data
+
+    def _setup_lst(self):
+        self._lst = self._data._data
+
+    def rowCount(self, parent):
+        return len(self._lst)
+
+    def data(self, index, role):
+        if role != Qt.ItemDataRole.DisplayRole:
+            return QVariant()
+
+        row = index.row()
+        column = index.column()
+
+        if self._headers[column] is "method":
+            n = self._lst[row].method
+            if n is None or n == "":
+                return self._trad['not_associated']
+            return n
+        elif self._headers[column] is "reach":
+            n = self._lst[row].reach
+            if n is None:
+                return self._trad['not_associated']
+            return next(filter(lambda edge: edge.id == n, self._river.edges())).name
+        elif self._headers[column] is "start_kp":
+            n = self._lst[row].start_kp
+            if n is None:
+                return self._trad['not_associated']
+            return n
+        elif self._headers[column] is "end_kp":
+            n = self._lst[row].end_kp
+            if n is None:
+                return self._trad['not_associated']
+            return n
+        elif self._headers[column] is "dif":
+            n = self._lst[row].dif
+            if n is None:
+                return self._trad['not_associated']
+            return n
+        elif self._headers[column] is "b":
+            n = self._lst[row].b
+            if n is None:
+                return self._trad['not_associated']
+            return n
+        elif self._headers[column] is "c":
+            n = self._lst[row].c
+            if n is None:
+                return self._trad['not_associated']
+            return n
+
+        return QVariant()
+
+    def setData(self, index, value, role=Qt.EditRole):
+        if not index.isValid() or role != Qt.EditRole:
+            return False
+
+        row = index.row()
+        column = index.column()
+
+        try:
+            if self._headers[column] != "reach":
+                self._undo.push(
+                    SetCommandSpec(
+                        self._lst, row, self._headers[column], value
+                    )
+                )
+            elif self._headers[column] == "reach":
+                print(self._river.edge(value).id)
+                self._undo.push(
+                    SetCommandSpec(
+                        self._lst, row, self._headers[column], self._river.edge(value).id
+                    )
+                )
+        except Exception as e:
+            logger.info(e)
+            logger.debug(traceback.format_exc())
+
+        self.dataChanged.emit(index, index)
+        return True
+
+    def add(self, row, parent=QModelIndex()):
+        self.beginInsertRows(parent, row, row - 1)
+
+        self._undo.push(
+            AddCommand(
+                self._data, self._lst, row
+            )
+        )
+
+        self.endInsertRows()
+        self.layoutChanged.emit()
+
+    def delete(self, rows, parent=QModelIndex()):
+        self.beginRemoveRows(parent, rows[0], rows[-1])
+
+        self._undo.push(
+            DelCommand(
+                self._data, self._lst, rows
+            )
+        )
+
+        self.endRemoveRows()
+        self.layoutChanged.emit()
+
+    def undo(self):
+        self._undo.undo()
+        self.layoutChanged.emit()
+
+    def redo(self):
+        self._undo.redo()
+        self.layoutChanged.emit()
+

src/View/DIFAdisTS/TableDefault.py

@@ -0,0 +1,108 @@
+# Table.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import logging
+import traceback
+from tools import trace, timer
+
+from PyQt5.QtCore import (
+    Qt, QVariant, QAbstractTableModel,
+    QCoreApplication, QModelIndex, pyqtSlot,
+    QRect,
+)
+
+from PyQt5.QtWidgets import (
+    QDialogButtonBox, QPushButton, QLineEdit,
+    QFileDialog, QTableView, QAbstractItemView,
+    QUndoStack, QShortcut, QAction, QItemDelegate,
+    QComboBox,
+)
+
+from View.Tools.PamhyrTable import PamhyrTableModel
+
+from View.DIFAdisTS.UndoCommand import (
+    SetCommand,
+)
+
+logger = logging.getLogger()
+
+_translate = QCoreApplication.translate
+
+class DIFTableDefaultModel(PamhyrTableModel):
+    def __init__(self, **kwargs):
+        super(DIFTableDefaultModel, self).__init__(**kwargs)
+
+    def data(self, index, role):
+        if role != Qt.ItemDataRole.DisplayRole:
+            return QVariant()
+
+        row = index.row()
+        column = index.column()
+
+        if self._headers[column] is "method":
+            n = self._data[row].method
+            if n is None:
+                return self._trad['not_associated']
+            return n
+        elif self._headers[column] is "dif":
+            n = self._data[row].dif
+            if n is None:
+                return self._trad['not_associated']
+            return n
+        elif self._headers[column] is "b":
+            n = self._data[row].b
+            if n is None:
+                return self._trad['not_associated']
+            return n
+        elif self._headers[column] is "c":
+            n = self._data[row].c
+            if n is None:
+                return self._trad['not_associated']
+            return n
+
+        return QVariant()
+
+    def setData(self, index, value, role=Qt.EditRole):
+        if not index.isValid() or role != Qt.EditRole:
+            return False
+
+        row = index.row()
+        column = index.column()
+
+        try:
+            if self._headers[column] is not None:
+                self._undo.push(
+                    SetCommand(
+                        self._data, row, self._headers[column], value
+                    )
+                )
+        except Exception as e:
+            logger.info(e)
+            logger.debug(traceback.format_exc())
+
+        self.dataChanged.emit(index, index)
+        return True
+
+    def undo(self):
+        self._undo.undo()
+        self.layoutChanged.emit()
+
+    def redo(self):
+        self._undo.redo()
+        self.layoutChanged.emit()
+

src/View/DIFAdisTS/UndoCommand.py

@@ -0,0 +1,174 @@
+# UndoCommand.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+from copy import deepcopy
+from tools import trace, timer
+
+from PyQt5.QtWidgets import (
+    QMessageBox, QUndoCommand, QUndoStack,
+)
+
+from Model.DIFAdisTS.DIFAdisTS import DIFAdisTS
+from Model.DIFAdisTS.DIFAdisTSList import DIFAdisTSList
+
+
+class SetCommand(QUndoCommand):
+    def __init__(self, data, row, column, new_value):
+        QUndoCommand.__init__(self)
+
+        self._data = data
+        self._row = row
+        self._column = column
+
+        if self._column == "method":
+            self._old = self._data[self._row].method
+        elif self._column == "dif":
+            self._old = self._data[self._row].dif
+        elif self._column == "b":
+            self._old = self._data[self._row].b
+        elif self._column == "c":
+            self._old = self._data[self._row].c
+
+        _type = float
+        if column == "method":
+            _type = str
+
+        self._new = _type(new_value)
+
+    def undo(self):
+        if self._column == "method":
+            self._data[self._row].method = self._old
+        elif self._column == "dif":
+            self._data[self._row].dif = self._old
+        elif self._column == "b":
+            self._data[self._row].b = self._old
+        elif self._column == "c":
+            self._data[self._row].c = self._old
+
+    def redo(self):
+        if self._column == "method":
+            self._data[self._row].method = self._new
+        elif self._column == "dif":
+            self._data[self._row].dif = self._new
+        elif self._column == "b":
+            self._data[self._row].b = self._new
+        elif self._column == "c":
+            self._data[self._row].c = self._new
+
+class SetCommandSpec(QUndoCommand):
+    def __init__(self, data, row, column, new_value):
+        QUndoCommand.__init__(self)
+
+        self._data = data
+        self._row = row
+        self._column = column
+
+        if self._column == "method":
+            self._old = self._data[self._row].method
+        elif self._column == "reach":
+            self._old = self._data[self._row].reach
+        elif self._column == "start_kp":
+            self._old = self._data[self._row].start_kp
+        elif self._column == "end_kp":
+            self._old = self._data[self._row].end_kp
+        elif self._column == "dif":
+            self._old = self._data[self._row].dif
+        elif self._column == "b":
+            self._old = self._data[self._row].b
+        elif self._column == "c":
+            self._old = self._data[self._row].c
+
+        _type = float
+        if column == "method":
+            _type = str
+        elif column == "reach":
+            _type = int
+
+        self._new = _type(new_value)
+
+    def undo(self):
+        if self._column == "method":
+            self._data[self._row].method = self._old
+        elif self._column == "reach":
+            self._data[self._row].reach = self._old
+        elif self._column == "start_kp":
+            self._data[self._row].start_kp = self._old
+        elif self._column == "end_kp":
+            self._data[self._row].end_kp = self._old
+        elif self._column == "dif":
+            self._data[self._row].dif = self._old
+        elif self._column == "b":
+            self._data[self._row].b = self._old
+        elif self._column == "c":
+            self._data[self._row].c = self._old
+
+    def redo(self):
+        if self._column == "method":
+            self._data[self._row].method = self._new
+        elif self._column == "reach":
+            self._data[self._row].reach = self._new
+        elif self._column == "start_kp":
+            self._data[self._row].start_kp = self._new
+        elif self._column == "end_kp":
+            self._data[self._row].end_kp = self._new
+        elif self._column == "dif":
+            self._data[self._row].dif = self._new
+        elif self._column == "b":
+            self._data[self._row].b = self._new
+        elif self._column == "c":
+            self._data[self._row].c = self._new
+
+class AddCommand(QUndoCommand):
+    def __init__(self, data, ics_spec, index):
+        QUndoCommand.__init__(self)
+
+        self._data = data
+        self._ics_spec = ics_spec
+        self._index = index
+        self._new = None
+
+    def undo(self):
+        self._data.delete_i([self._index])
+
+    def redo(self):
+        if self._new is None:
+            self._new = self._data.new(self._index)
+        else:
+            self._data.insert(self._index, self._new)
+
+class DelCommand(QUndoCommand):
+    def __init__(self, data, ics_spec, rows):
+        QUndoCommand.__init__(self)
+
+        self._data = data
+        self._ics_spec = ics_spec
+        self._rows = rows
+        #self._data = data
+
+        self._ic = []
+        for row in rows:
+            self._ic.append((row, self._ics_spec[row]))
+        self._ic.sort()
+
+    def undo(self):
+        for row, el in self._ic:
+            self._data.insert(row, el)
+
+    def redo(self):
+        self._data.delete_i(self._rows)
+

src/View/DIFAdisTS/Window.py

@@ -0,0 +1,290 @@
+# Window.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import os
+import logging
+
+from tools import trace, timer, logger_exception
+
+from View.Tools.PamhyrWindow import PamhyrWindow
+
+from PyQt5.QtGui import (
+    QKeySequence, QIcon,
+)
+
+from PyQt5.QtCore import (
+    Qt, QVariant, QAbstractTableModel,
+    QCoreApplication, QModelIndex, pyqtSlot,
+    QRect, QItemSelectionModel,
+)
+
+from PyQt5.QtWidgets import (
+    QDialogButtonBox, QPushButton, QLineEdit,
+    QFileDialog, QTableView, QAbstractItemView,
+    QUndoStack, QShortcut, QAction, QItemDelegate,
+    QComboBox, QVBoxLayout, QHeaderView, QTabWidget,
+    QVBoxLayout, QToolBar, QAction, QToolButton,
+)
+
+from Modules import Modules
+
+from View.DIFAdisTS.TableDefault import (
+    DIFTableDefaultModel,
+)
+
+from View.DIFAdisTS.Table import (
+    DIFTableModel, ComboBoxDelegate,
+)
+
+from View.DIFAdisTS.translate import DIFAdisTSTranslate
+
+from Solver.Mage import Mage8
+
+_translate = QCoreApplication.translate
+
+logger = logging.getLogger()
+
+
+class DIFAdisTSWindow(PamhyrWindow):
+    _pamhyr_ui = "DIFAdisTS"
+    _pamhyr_name = "DIF AdisTS"
+
+    def __init__(self, data=None, study=None, config=None, parent=None):
+        self._data = []
+        self._data.append(data)
+        trad = DIFAdisTSTranslate()
+
+        name = (
+            trad[self._pamhyr_name] +
+            " - " + study.name +
+            " - " + self._data[0].name
+        )
+
+        super(DIFAdisTSWindow, self).__init__(
+            title=name,
+            study=study,
+            config=config,
+            trad=trad,
+            parent=parent
+        )
+
+        self._hash_data.append(data)
+
+        self._dif_adists_lst = study.river.dif_adists
+
+        self.setup_table()
+
+        self.ui.setWindowTitle(self._title)
+
+    def setup_table(self):
+
+        path_icons = os.path.join(self._get_ui_directory(), f"ressources")
+
+        table_default = self.find(QTableView, f"tableView")
+
+        self._delegate_method = ComboBoxDelegate(
+            trad=self._trad,
+            data=self._study.river,
+            ic_spec_lst=self._data[0]._data,
+            parent=self,
+            mode="method"
+        )
+
+        self._table = DIFTableDefaultModel(
+            table_view=table_default,
+            table_headers=self._trad.get_dict("table_headers"),
+            editable_headers=["method", "dif", "b", "c"],
+            delegates={
+                "method": self._delegate_method
+            },
+            data=self._data,
+            undo=self._undo_stack,
+            trad=self._trad
+        )
+
+        table_default.setModel(self._table)
+        table_default.setSelectionBehavior(QAbstractItemView.SelectRows)
+        table_default.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
+        table_default.setAlternatingRowColors(True)
+
+        layout = self.find(QVBoxLayout, f"verticalLayout_1")
+        toolBar = QToolBar()
+        layout.addWidget(toolBar)
+
+        action_add = QAction(self)
+        action_add.setIcon(QIcon(os.path.join(path_icons, f"add.png")))
+        action_add.triggered.connect(self.add)
+        action_delete = QAction(self)
+        action_delete.setIcon(QIcon(os.path.join(path_icons, f"del.png")))
+        action_delete.triggered.connect(self.delete)
+
+        toolBar.addAction(action_add)
+        toolBar.addAction(action_delete)
+
+        self.table_spec = QTableView()
+        layout.addWidget(self.table_spec)
+
+        self._delegate_reach = ComboBoxDelegate(
+            trad=self._trad,
+            data=self._study.river,
+            ic_spec_lst=self._data[0]._data,
+            parent=self,
+            mode="reaches"
+        )
+        self._delegate_kp = ComboBoxDelegate(
+            trad=self._trad,
+            data=self._study.river,
+            ic_spec_lst=self._data[0]._data,
+            parent=self,
+            mode="kp"
+        )
+
+        self._table_spec = DIFTableModel(
+            table_view=self.table_spec,
+            table_headers=self._trad.get_dict("table_headers_spec"),
+            editable_headers=["method", "reach", "start_kp", "end_kp", "dif", "b", "c"],
+            delegates={
+                "method": self._delegate_method,
+                "reach": self._delegate_reach,
+                "start_kp": self._delegate_kp,
+                "end_kp": self._delegate_kp
+            },
+            data=self._data[0],
+            undo=self._undo_stack,
+            trad=self._trad,
+            river=self._study.river
+        )
+
+        self.table_spec.setModel(self._table_spec)
+        self.table_spec.setSelectionBehavior(QAbstractItemView.SelectRows)
+        self.table_spec.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
+        self.table_spec.setAlternatingRowColors(True)
+
+        selectionModel = self.table_spec.selectionModel()
+        index = self.table_spec.model().index(0, 0)
+
+        selectionModel.select(
+            index,
+            QItemSelectionModel.Rows |
+            QItemSelectionModel.ClearAndSelect |
+            QItemSelectionModel.Select
+        )
+        self.table_spec.scrollTo(index)
+
+    def index_selected_row(self):
+        #table = self.find(QTableView, f"tableView")
+        table = self.table_spec
+        rows = table.selectionModel()\
+                    .selectedRows()
+
+        if len(rows) == 0:
+            return 0
+
+        return rows[0].row()
+
+    def index_selected_rows(self):
+        #table = self.find(QTableView, f"tableView")
+        table = self.table_spec
+        return list(
+            # Delete duplicate
+            set(
+                map(
+                    lambda i: i.row(),
+                    table.selectedIndexes()
+                )
+            )
+        )
+
+    def move_up(self):
+        row = self.index_selected_row()
+        self._table.move_up(row)
+        self._update()
+
+    def move_down(self):
+        row = self.index_selected_row()
+        self._table.move_down(row)
+        self._update()
+
+    def _copy(self):
+        rows = list(
+            map(
+                lambda row: row.row(),
+                self.tableView.selectionModel().selectedRows()
+            )
+        )
+
+        table = list(
+            map(
+                lambda eic: list(
+                    map(
+                        lambda k: eic[1][k],
+                        ["kp", "discharge", "elevation"]
+                    )
+                ),
+                filter(
+                    lambda eic: eic[0] in rows,
+                    enumerate(self._ics.lst())
+                )
+            )
+        )
+
+        self.copyTableIntoClipboard(table)
+
+    def _paste(self):
+        header, data = self.parseClipboardTable()
+
+        if len(data) + len(header) == 0:
+            return
+
+        logger.debug(
+            "DIF: Paste: " +
+            f"header = {header}, " +
+            f"data = {data}"
+        )
+
+        try:
+            row = self.index_selected_row()
+            # self._table.paste(row, header, data)
+            self._table.paste(row, [], data)
+        except Exception as e:
+            logger_exception(e)
+
+        self._update()
+
+    def _undo(self):
+        self._table.undo()
+        self._update()
+
+    def _redo(self):
+        self._table.redo()
+        self._update()
+
+    def add(self):
+        rows = self.index_selected_rows()
+        if len(self._data[0]._data) == 0 or len(rows) == 0:
+            self._table_spec.add(0)
+        else:
+            self._table_spec.add(rows[0])
+
+    def delete(self):
+        print("del")
+        rows = self.index_selected_rows()
+        if len(rows) == 0:
+            print("len 0")
+            return
+        self._table_spec.delete(rows)

src/View/DIFAdisTS/translate.py

@@ -0,0 +1,50 @@
+# translate.py -- Pamhyr
+# Copyright (C) 2023-2024  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+from PyQt5.QtCore import QCoreApplication
+
+from View.Translate import MainTranslate
+
+_translate = QCoreApplication.translate
+
+
+class DIFAdisTSTranslate(MainTranslate):
+    def __init__(self):
+        super(DIFAdisTSTranslate, self).__init__()
+
+        self._dict["DIF AdisTS"] = _translate(
+            "DIFAdisTS", "DIF AdisTS")
+
+        self._dict["kp"] = self._dict["unit_kp"]
+
+        self._sub_dict["table_headers"] = {
+            "method": self._dict["method"],
+            "dif": _translate("Unit", "DIF"),
+            "b": _translate("Unit", "Coeff b"),
+            "c": _translate("Unit", "Coeff c"),
+        }
+
+        self._sub_dict["table_headers_spec"] = {
+            "method": self._dict["method"],
+            "reach": self._dict["reach"],
+            "start_kp": _translate("Unit", "Start_KP (m)"),
+            "end_kp": _translate("Unit", "End_KP (m)"),
+            "dif": _translate("Unit", "DIF"),
+            "b": _translate("Unit", "Coeff b"),
+            "c": _translate("Unit", "Coeff c"),
+        }

src/View/Geometry/MeshingDialog.py

@@ -58,6 +58,7 @@ class MeshingDialog(PamhyrDialog):
         self._end_cs = -1
         self._begin_dir = "un"
         self._end_dir = "np"
+        self._origin = self._reach.profile(0)
 
         self._init_default_values_profiles()
         self._init_default_values_guidelines()
@@ -67,17 +68,6 @@ class MeshingDialog(PamhyrDialog):
             self._space_step
         )
 
-        lm_dict = self._trad.get_dict("lm_dict")
-        self.combobox_add_items(
-            "comboBox_lm", list(
-                map(
-                    lambda x: lm_dict[x],
-                    ["1", "2", "3"]
-                )
-            )
-        )
-        self.set_combobox_text("comboBox_lm", self._lm)
-
         if self._linear:
             self.set_radio_button("radioButton_linear", True)
         else:
@@ -118,8 +108,8 @@ class MeshingDialog(PamhyrDialog):
         gl, _ = self._reach.compute_guidelines()
         gl = list(gl)
 
-        bgl = ['un'] + gl
-        egl = gl + ['np']
+        bgl = ['un'] + gl + ['np']
+        egl = ['un'] + gl + ['np']
 
         self.combobox_add_items("comboBox_begin_gl", bgl)
         self.combobox_add_items("comboBox_end_gl", egl)
@@ -135,6 +125,10 @@ class MeshingDialog(PamhyrDialog):
     def lplan(self):
         return self._lplan
 
+    @property
+    def origin(self):
+        return self._origin
+
     @property
     def lm(self):
         return int(self._lm)
@@ -145,11 +139,11 @@ class MeshingDialog(PamhyrDialog):
 
     @property
     def begin_cs(self):
-        return self._begin_cs + 1
+        return self._begin_cs
 
     @property
     def end_cs(self):
-        return self._end_cs + 1
+        return self._end_cs
 
     @property
     def begin_dir(self):
@@ -171,6 +165,9 @@ class MeshingDialog(PamhyrDialog):
         self._begin_cs = self.profiles.index(p1)
         self._end_cs = self.profiles.index(p2)
 
+        origin = self.get_combobox_text("comboBox_origin")
+        self._origin = self.profiles.index(origin)
+
         self._begin_dir = self.get_combobox_text("comboBox_begin_gl")
         self._end_dir = self.get_combobox_text("comboBox_end_gl")
 

src/View/Geometry/PlotAC.py

@@ -129,7 +129,7 @@ class PlotAC(PamhyrPlot):
 
             if txt.strip() in self.complete_gl:
                 color = self.color_complete_gl[
-                    lcomplete.index(txt)
+                    lcomplete.index(txt) % len(self.color_complete_gl)
                 ]
             else:
                 color = self.color_incomplete_gl[

src/View/Geometry/PlotKPZ.py

@@ -25,8 +25,11 @@ logger = logging.getLogger()
 
 
 class PlotKPZ(PamhyrPlot):
-    def __init__(self, canvas=None, trad=None, data=None, toolbar=None,
+    def __init__(self, canvas=None, trad=None,
+                 study=None, data=None, toolbar=None,
                  parent=None):
+        self._study = study
+
         super(PlotKPZ, self).__init__(
             canvas=canvas,
             trad=trad,
@@ -75,6 +78,7 @@ class PlotKPZ(PamhyrPlot):
         self.draw_current()
         self.draw_gl()
         self.draw_bottom()
+        self.draw_profiles_hs(self._data)
 
         self.idle()
         self._init = True
@@ -167,7 +171,9 @@ class PlotKPZ(PamhyrPlot):
 
             self.line_kp_zgl.append(
                 self.canvas.axes.plot(
-                    kp, z, lw=1., color=self.colors[ind]
+                    kp, z, lw=1.,
+                    color=self.colors[ind % len(self.colors)],
+                    linestyle=self.linestyle[ind // len(self.colors)]
                 )
             )
             ind += 1
@@ -182,6 +188,34 @@ class PlotKPZ(PamhyrPlot):
             color='lightgrey'
         )
 
+    def draw_profiles_hs(self, reach):
+        lhs = filter(
+            lambda hs: hs._input_reach.reach is reach,
+            self._study.river.hydraulic_structures.lst
+        )
+
+        for hs in lhs:
+            x = hs.input_kp
+            z_min = reach.get_z_min()
+            z_max = reach.get_z_max()
+
+            self.canvas.axes.plot(
+                [x, x],
+                [min(z_min), max(z_max)],
+                linestyle="--",
+                lw=1.,
+                color=self.color_plot_previous,
+            )
+
+            self.canvas.axes.annotate(
+                " > " + hs.name,
+                (x, max(z_max)),
+                horizontalalignment='left',
+                verticalalignment='top',
+                annotation_clip=True,
+                fontsize=9, color=self.color_plot_previous,
+            )
+
     @timer
     def update(self):
         if not self._init:

src/View/Geometry/PlotXY.py

@@ -61,6 +61,7 @@ class PlotXY(PamhyrPlot):
             return
 
         self.draw_xy()
+        self.draw_lr()
         self.draw_gl()
         self.draw_current()
 
@@ -90,6 +91,37 @@ class PlotXY(PamhyrPlot):
             )
             self.line_xy.append(line)
 
+    def draw_lr(self):
+        lx = []
+        ly = []
+        rx = []
+        ry = []
+
+        self.line_lr = []
+        for x, y in zip(self.data.get_x(),
+                        self.data.get_y()):
+            lx.append(x[0])
+            ly.append(y[0])
+
+            rx.append(x[-1])
+            ry.append(y[-1])
+
+        line = self.canvas.axes.plot(
+            lx, ly,
+            color=self.color_plot_river_bottom,
+            linestyle="dotted",
+            lw=1.,
+        )
+        self.line_lr.append(line)
+
+        line = self.canvas.axes.plot(
+            rx, ry,
+            color=self.color_plot_river_bottom,
+            linestyle="dotted",
+            lw=1.,
+        )
+        self.line_lr.append(line)
+
     def draw_gl(self):
         x_complete = self.data.get_guidelines_x()
         y_complete = self.data.get_guidelines_y()
@@ -98,7 +130,8 @@ class PlotXY(PamhyrPlot):
         self.line_gl = []
         for x, y in zip(x_complete, y_complete):
             line = self.canvas.axes.plot(
-                x, y, color=self.colors[ind]
+                x, y, color=self.colors[ind % len(self.colors)],
+                linestyle=self.linestyle[ind // len(self.colors)]
             )
             self.line_gl.append(line)
             ind += 1
@@ -139,6 +172,7 @@ class PlotXY(PamhyrPlot):
         if self.data is None:
             return
 
+        self.update_lr()
         self.update_gl()
         self.update_current()
 
@@ -207,3 +241,9 @@ class PlotXY(PamhyrPlot):
                     self.data.profile(after).y()
                 )
                 self.after_plot_selected.set_visible(True)
+
+    def update_lr(self):
+        for line in self.line_lr:
+            line[0].remove()
+
+        self.draw_lr()