ui: Minor change.

pamhyr: Fix pep8.
Results: Fix reach selection with disable reaches in network.
2026-10-30 03:20:41 +01:00 · 2024-07-16 10:56:13 +02:00 · 2024-07-16 10:43:12 +02:00 · 2024-07-16 10:39:41 +02:00 · 2024-07-16 09:46:56 +02:00 · 2024-07-16 09:43:32 +02:00
357 changed files with 12244 additions and 6277 deletions
@@ -1,5 +1,5 @@
 # .gitlab-ci.yml -- Pamhyr gitlab-ci
-# Copyright (C) 2023  INRAE
+# 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
@@ -29,9 +29,9 @@ stages:
 #############

 variables:
-  MAGE_VERSION: "v8.3.4"
+  MAGE_8_VERSION: "v8.3.6"

-dl-mage-doc:
+dl-mage8-doc:
  stage: downloads
  tags:
    - linux
@@ -40,46 +40,48 @@ dl-mage-doc:
  script:
    - mkdir -p doc
    - cd doc
-    - curl -L -o mage8.pdf https://gitlab.irstea.fr/jean-baptiste.faure/mage/-/releases/$MAGE_VERSION/downloads/documents/Mage-8_Documentation.pdf
+    - curl -L -o mage8.pdf https://gitlab.irstea.fr/jean-baptiste.faure/mage/-/releases/$MAGE_8_VERSION/downloads/documents/Mage-8_Documentation.pdf
  artifacts:
    paths:
      - doc/mage8.pdf

-dl-mage-linux:
+dl-mage8-linux:
  stage: downloads
  tags:
    - linux
  rules:
    - if: $CI_COMMIT_BRANCH == 'ci-test' || $CI_COMMIT_BRANCH == 'master' || $CI_COMMIT_TAG
  script:
-    - curl -L -o mage.tgz https://gitlab.irstea.fr/jean-baptiste.faure/mage/-/releases/$MAGE_VERSION/downloads/packages/mage_linux.tgz
-    - mkdir -p mage-linux
-    - cd mage-linux
-    - tar xvf ../mage.tgz
+    - curl -L -o mage8.tgz https://gitlab.irstea.fr/jean-baptiste.faure/mage/-/releases/$MAGE_8_VERSION/downloads/packages/mage_linux.tgz
+    - mkdir -p mage8-linux
+    - cd mage8-linux
+    - tar xvf ../mage8.tgz
  artifacts:
    paths:
-      - mage-linux/mage
-      - mage-linux/mage_extraire
-      - mage-linux/mailleurTT
-      - mage-linux/libbief.so
+      - mage8-linux/mage
+      - mage8-linux/mage_as7
+      - mage8-linux/mage_extraire
+      - mage8-linux/mailleurTT
+      - mage8-linux/libbief.so

-dl-mage-windows:
+dl-mage8-windows:
  stage: downloads
  tags:
    - linux
  rules:
    - if: $CI_COMMIT_BRANCH == 'ci-test' || $CI_COMMIT_BRANCH == 'master' || $CI_COMMIT_TAG
  script:
-    - curl -L -o mage.tgz https://gitlab.irstea.fr/jean-baptiste.faure/mage/-/releases/$MAGE_VERSION/downloads/packages/mage_windows.tgz
-    - mkdir -p mage-windows
-    - cd mage-windows
-    - tar xvf ../mage.tgz
+    - curl -L -o mage8.tgz https://gitlab.irstea.fr/jean-baptiste.faure/mage/-/releases/$MAGE_8_VERSION/downloads/packages/mage_windows.tgz
+    - mkdir -p mage8-windows
+    - cd mage8-windows
+    - tar xvf ../mage8.tgz
  artifacts:
    paths:
-      - mage-windows/mage.exe
-      - mage-windows/mage_extraire.exe
-      - mage-windows/mailleurTT.exe
-      - mage-windows/libbief.dll
+      - mage8-windows/mage.exe
+      - mage8-windows/mage_as7.exe
+      - mage8-windows/mage_extraire.exe
+      - mage8-windows/mailleurTT.exe
+      - mage8-windows/libbief.dll

 #############
 # CONFIGURE #
@@ -222,9 +224,9 @@ build-linux:
  rules:
    - if: $CI_COMMIT_BRANCH == 'ci-test' || $CI_COMMIT_BRANCH == 'master' || $CI_COMMIT_TAG
  needs:
-    - job: dl-mage-linux
+    - job: dl-mage8-linux
      artifacts: true
-    - job: dl-mage-doc
+    - job: dl-mage8-doc
      artifacts: true
    - job: set-version
      artifacts: true
@@ -249,28 +251,32 @@ build-linux:
    - pyinstaller -y --paths linux-venv/lib/python3.8/site-packages ../src/pamhyr.py
    # Create directory
    - mkdir -p pamhyr
-    - mkdir -p pamhyr/pamhyr
-    - mkdir -p pamhyr/pamhyr/_internal
+    - mkdir -p pamhyr/_internal
    # Copy Pamhyr info
-    - cp -v ../VERSION pamhyr/pamhyr/_internal/
-    - cp -v ../AUTHORS pamhyr/pamhyr/_internal/
-    - cp -v ../LICENSE pamhyr/pamhyr/_internal/
-    - cp -v ../src/motd.txt pamhyr/pamhyr/_internal/
+    - cp -v ../VERSION pamhyr/_internal/
+    - cp -v ../AUTHORS pamhyr/_internal/
+    - cp -v ../LICENSE pamhyr/_internal/
+    - cp -v ../src/motd.txt pamhyr/_internal/
    # Copy mage
-    - mkdir -p pamhyr/mage
-    - cp -v ../mage-linux/* pamhyr/mage/
+    - mkdir -p pamhyr/mage8
+    - cp -v ../mage8-linux/* pamhyr/mage8/
    # Copy Pamhyr
-    - cp -r dist/pamhyr pamhyr/
+    - cp -r dist/pamhyr/* pamhyr/
+    # Pamhyr script to force x11
+    - echo '#!/usr/bin/env bash' > pamhyr/pamhyr-x11
+    - echo "" >> pamhyr/pamhyr-x11
+    - echo "GDK_BACKEND=x11 ./pamhyr $@" >> pamhyr/pamhyr-x11
+    - chmod +x pamhyr/pamhyr-x11
    # Copy Pamhyr resources
-    - mkdir -p pamhyr/pamhyr/_internal/View
-    - mkdir -p pamhyr/pamhyr/_internal/View/ui
-    - mkdir -p pamhyr/pamhyr/_internal/View/ui/Widgets
-    - cp -r ../src/View/ui/*.ui pamhyr/pamhyr/_internal/View/ui/
-    - cp -r ../src/View/ui/ressources/ pamhyr/pamhyr/_internal/View/ui
-    - cp -r ../src/View/ui/Widgets/*.ui pamhyr/pamhyr/_internal/View/ui/Widgets
+    - mkdir -p pamhyr/_internal/View
+    - mkdir -p pamhyr/_internal/View/ui
+    - mkdir -p pamhyr/_internal/View/ui/Widgets
+    - cp -r ../src/View/ui/*.ui pamhyr/_internal/View/ui/
+    - cp -r ../src/View/ui/ressources/ pamhyr/_internal/View/ui
+    - cp -r ../src/View/ui/Widgets/*.ui pamhyr/_internal/View/ui/Widgets
    # Copy lang
-    - mkdir -p pamhyr/pamhyr/_internal/lang
-    - cp -r ../src/lang/*.qm pamhyr/pamhyr/_internal/lang
+    - mkdir -p pamhyr/_internal/lang
+    - cp -r ../src/lang/*.qm pamhyr/_internal/lang
    # Copy tests cases
    - mkdir -p pamhyr/tests_cases/
    - mkdir -p pamhyr/tests_cases/Saar
@@ -298,10 +304,6 @@ build-linux:
    # Copy TP charriage
    - mkdir -p pamhyr/doc/TP_charriage/
    - cp ../doc/users/TP_charriage/* pamhyr/doc/TP_charriage
-    # Create running script
-    - echo "#!/bin/sh" > pamhyr/Pamhyr2
-    - echo "./pamhyr/pamhyr $@" >> pamhyr/Pamhyr2
-    - chmod u+x pamhyr/Pamhyr2
  artifacts:
    paths:
      - linux/pamhyr
@@ -313,9 +315,9 @@ build-windows:
  rules:
    - if: $CI_COMMIT_BRANCH == 'ci-test' || $CI_COMMIT_BRANCH == 'master' || $CI_COMMIT_TAG
  needs:
-    - job: dl-mage-windows
+    - job: dl-mage8-windows
      artifacts: true
-    - job: dl-mage-doc
+    - job: dl-mage8-doc
      artifacts: true
    - job: set-version
      artifacts: true
@@ -335,7 +337,8 @@ build-windows:
    - python -m pip install -r ..\requirements.txt
    - python -m pip install -U -r ..\requirements.txt
    # Run Pyinstaller
-    - pyinstaller -y ..\src\pamhyr.py
+    # - pyinstaller --noconsole -y ..\src\pamhyr.py
+    - pyinstaller -i ../src/View/ui/ressources/icon.ico --hide-console hide-early -y ..\src\pamhyr.py
    # Create directory
    - mkdir pamhyr
    - dir
@@ -421,10 +424,10 @@ linux-build-hash:
    - if: $CI_COMMIT_BRANCH == 'ci-test' || $CI_COMMIT_BRANCH == 'master' || $CI_COMMIT_TAG
  script:
    - cd linux
-    - sha256sum -b pamhyr/pamhyr/pamhyr > pamhyr/pamhyr/pamhyr.sha256
+    - sha256sum -b pamhyr/pamhyr > pamhyr/pamhyr.sha256
  artifacts:
    paths:
-      - linux/pamhyr/pamhyr/pamhyr.sha256
+      - linux/pamhyr/pamhyr.sha256

 windows-build-hash:
  stage: hash
@@ -438,10 +441,10 @@ windows-build-hash:
    - if: $CI_COMMIT_BRANCH == 'ci-test' || $CI_COMMIT_BRANCH == 'master' || $CI_COMMIT_TAG
  script:
    - cd windows
-    - sha256sum -b pamhyr/pamhyr/pamhyr.exe > pamhyr/pamhyr/pamhyr.exe.sha256
+    - sha256sum -b pamhyr/pamhyr.exe > pamhyr/pamhyr.exe.sha256
  artifacts:
    paths:
-      - windows/pamhyr/pamhyr/pamhyr.exe.sha256
+      - windows/pamhyr/pamhyr.exe.sha256

 pkg-hash:
  stage: hash
@@ -1,5 +1,5 @@
 # documentation.org -- Pamhyr developers documentation
-# Copyright (C) 2023  INRAE
+# 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
@@ -369,6 +369,7 @@ of Bar (Listing [[sql-bar]] and [[sql-foo]]).
            CREATE TABLE bar (
              id INTEGER NOT NULL PRIMARY KEY,
              x INTEGER NOT NULL,
+              y INTEGER NOT NULL,
              foo_id INTEGER NOT NULL,
              FOREIGN KEY(foo_id) REFERENCES foo(id),
            )""")
@@ -455,6 +456,15 @@ of Bar (Listing [[sql-bar]] and [[sql-foo]]).
              bar._sql_save(execute, data=data)
 #+end_src

+Let see the results database scheme for Pamhyr2 at version v0.0.7 in
+Figure [[sql_schema]].
+
+#+NAME: sql_schema
+#+ATTR_LATEX: :width 16cm
+#+CAPTION: SQLite database scheme at Pamhyr2 version v0.0.7 (generate with [[https://gitlab.com/Screwtapello/sqlite-schema-diagram]])
+[[./images/schema_v0.0.7.png]]
+
+
 [fn:sqlite] The SQLite web site: https://www.sqlite.org/index.html
 (last access 2023-09-20)

@@ -538,44 +548,44 @@ generic value from optional parameters, for examples:
 #+NAME: window
 #+CAPTION: Example of Pamhyr2 window
 #+begin_src python :python python3 :results output :noweb yes
-    from View.Tools.PamhyrWindow import PamhyrWindow
-    from View.My.Translate import MyTranslate
-    from View.My.Table import MyTableModel
+  from View.Tools.PamhyrWindow import PamhyrWindow
+  from View.My.Translate import MyTranslate
+  from View.My.Table import MyTableModel

-    class MyWindow(PamhyrWindow):
-        _pamhyr_ui = "MyUI"
-        _pamhyr_name = "My window"
+  class MyWindow(PamhyrWindow):
+      _pamhyr_ui = "MyUI"
+      _pamhyr_name = "My window"

-        def __init__(self, my_data=None,
-                     study=None, config=None,
-                     parent=None):
-            self._my_data = my_data
+      def __init__(self, study=None, config=None,
+                   my_data=None,
+                   parent=None):
+          self._my_data = my_data

-            super(MyWindow, self).__init__(
-                # Window title
-                title = self._pamhyr_name + " - " + study.name,
-                # Window standard data
-                study = study, config = config,
-                trad = MyTranslate(),
-                parent = parent,
-                # Activate undo/redo and copy/paste shortcut
-                options = ["undo", "copy"]
-            )
+          super(MyWindow, self).__init__(
+              # Window title
+              title = self._pamhyr_name + " - " + study.name,
+              # Window standard data
+              study = study, config = config,
+              trad = MyTranslate(),
+              parent = parent,
+              # Activate undo/redo and copy/paste shortcut
+              options = ["undo", "copy"]
+          )

-            # Add custom data to hash window computation
-            self._hash_data.append(self._my_data)
+          # Add custom data to hash window computation
+          self._hash_data.append(self._my_data)

-            # Setup custom window components
-            self.setup_table()
-            self.setup_connections()
+          # Setup custom window components
+          self.setup_table()
+          self.setup_connections()

-        def setup_table(self):
-            # Init table(s)...
+      def setup_table(self):
+          # Init table(s)...

-        def setup_connections(self):
-            # Init action connection(s)...
+      def setup_connections(self):
+          # Init action connection(s)...

-        # ...
+      # ...
 #+end_src

 Typically we called method =setup_*=, the method to initialize some
@@ -636,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)
@@ -661,11 +671,13 @@ creation, this stack is accessible at =self._undo_stack=.

 *** Plot

-To define a new plot you can create a class who inherit to APlot. The
-creator need threee argument:
+To define a new plot you can create a class who inherit to
+PamhyrPlot. The creator need at leaste five argument:
 - A =canvas= of type =MplCanvas=
+ - A (optional) =trad= of type =PamhyrTranslate=
 - A =data= used in =draw= and =update= to create and update the plot
 - A optional =toolbar= of type =PamhyrToolbar=
+ - A =parent= window
 This class must implement two method =draw= and =update=, the first
 method to draw the plot from scratch, the second to update the plot if
 data has changed.
@@ -673,19 +685,36 @@ data has changed.
 #+begin_src python :python python3 :results output :noweb yes
  from View.Tools.PamhyrPlot import PamhyrPlot

-  class MyPlot(APlot):
-      def __init__(self, canvas=None, data=None, toolbar=None):
+  class MyPlot(PamhyrPlot):
+      def __init__(self, canvas=None, trad=None, toolbar=None
+                   data=None, parent=None):
          super(MyPlot, self).__init__(
              canvas=canvas,
+              trad=trad,
              data=data,
-              toolbar=toolbar
+              toolbar=toolbar,
+              parent=parent
          )

+        self.label_x = self._trad["x"]
+        self.label_y = self._trad["y"]
+
+        # Optional configuration
+        self._isometric_axis = False
+
+        self._auto_relim_update = True
+        self._autoscale_update = True
+
      def draw(self):
          # Draw function code...

-      def update(self, ind = None):
+      def update(self):
          # Update function code...
+
+      def clear(self):
+          # Clear plot values...
+
+      # ...
 #+end_src

 ** Solver
@@ -745,7 +774,7 @@ execute a code on distant computer, for example, over ssh.
                  style=dashed;
                  subgraph cluster021 {
                      label="Solver Classes";
-                      classSolverM7[label="Mage7", fillcolor=6];
+                      //classSolverM7[label="Mage7", fillcolor=6];
                      classSolverM8[label="Mage8", fillcolor=6];
                      classSolverR[label="RubarBE", fillcolor=6];
                  }
@@ -828,7 +857,7 @@ solver and get results:
 - (2.1) The solver read the input file(s)
 - (2.2) The solver compute results and write it to solver output
   file(s)
- - (3) Pamhyr2 create a Reuslts
+ - (3) Pamhyr2 create a =Results= object
 - (3.1) The Pamhyr2 solver class read solver output file(s) and
   complete Results with readed data

@@ -958,8 +987,16 @@ different methods:

 ** Unit tests

-The unit tests is actually not implemented in Pamhyr2, it is a *work
-in progress*.
+A very small part of Pamhyr2 has unit test. This part is limited to the Model.
+
+#+begin_src shell
+  python3 -m venv test
+  . test test/bin/activate
+  pip3 install -U -r ./full-requirements.txt
+
+  cd src/
+  python3 -Walways -m unittest discovert -v -t .
+#+end_src

 ** The debug mode

@@ -970,14 +1007,14 @@ line:
 ./Pamhyr2 debug
 #+end_src

-This mode add some log and add two action in main window menu:
-"About/Debug" open a window with Python Repl in current Python
-environement, and "About/Debug SQLite" who open the application
+This mode add some log and add two action in main window menu: "About
+> Debug" open a window with Python Repl in current Python
+environement, and "About > Debug SQLite" who open the application
 SQLiteBrowser (if installed) on current Study to explore the study
 data base file.

 #+NAME: debug-repl
-#+ATTR_LATEX: :width 12cm
+#+ATTR_LATEX: :width 14cm
 #+CAPTION: Pamhyr2 debug Python REPL
 [[./images/python-debug-repl.png]]

@@ -11,7 +11,8 @@
 \usepackage[absolute]{textpos}
 \usepackage{titlesec}
 \usepackage{amssymb}
-\usepackage{tcolorbox}
+\usepackage[minted,xparse,breakable]{tcolorbox}
+\usepackage{pmboxdraw}

 \usepackage{enumitem}
 \setlist[enumerate]{itemsep=-0.5em}
@@ -140,7 +141,7 @@
 \setminted[llvm]{breaklines,fontsize=\footnotesize,encoding=utf8}

 %% Add box arrond of minted
-\BeforeBeginEnvironment{minted}{\begin{tcolorbox}[boxsep=0pt, left=0.1cm, right=0.1cm, arc=0pt, boxrule=0.5pt, colback=white]}%
+\BeforeBeginEnvironment{minted}{\begin{tcolorbox}[breakable, boxsep=0pt, left=0.1cm, right=0.1cm, arc=0pt, boxrule=0.5pt, colback=white]}%
 \AfterEndEnvironment{minted}{\end{tcolorbox}}%

 \makeatletter
@@ -10,3 +10,5 @@ colorama>=0.4.3
 pyinstaller>=5.11.0
 shapely>=2.0.1
 lxml>=4.9.3
+platformdirs>=4.2.0
+pyshp>=2.3.1
@@ -0,0 +1,3 @@
+@echo off
+
+start cmd /c pamhyr.exe debug
@@ -0,0 +1,3 @@
+#! /bin/sh
+
+./pamhyr debug
@@ -16,34 +16,35 @@ rem along with this program.  If not, see <https://www.gnu.org/licenses/>.

@ECHO ON

-mkdir pamhyr\pamhyr\_internal
-xcopy /s /e /y dist\pamhyr pamhyr\pamhyr
+mkdir pamhyr\_internal
+xcopy /s /e /y dist\pamhyr pamhyr

 rem Copy data
-mkdir pamhyr\pamhyr\_internal\lang
-mkdir pamhyr\pamhyr\_internal\View\ui\ressources
-mkdir pamhyr\pamhyr\_internal\View\ui\Widgets
+mkdir pamhyr\_internal\lang
+mkdir pamhyr\_internal\View\ui\ressources
+mkdir pamhyr\_internal\View\ui\Widgets

 rem UI
-copy /y ..\src\View\ui\ressources\ pamhyr\pamhyr\_internal\View\ui\ressources
-copy /y ..\src\View\ui\Widgets\*.ui pamhyr\pamhyr\_internal\View\ui\Widgets
-copy /y ..\src\View\ui\*.ui pamhyr\pamhyr\_internal\View\ui\
+copy /y ..\src\View\ui\ressources\ pamhyr\_internal\View\ui\ressources
+copy /y ..\src\View\ui\Widgets\*.ui pamhyr\_internal\View\ui\Widgets
+copy /y ..\src\View\ui\*.ui pamhyr\_internal\View\ui\

 rem Lang
-copy /y ..\src\lang\*.qm pamhyr\pamhyr\_internal\lang\
+copy /y ..\src\lang\*.qm pamhyr\_internal\lang\

 rem Information
-copy /y ..\VERSION pamhyr\pamhyr\_internal
-copy /y ..\AUTHORS pamhyr\pamhyr\_internal
-copy /y ..\LICENSE pamhyr\pamhyr\_internal
-copy /y ..\src\motd.txt pamhyr\pamhyr\_internal
+copy /y ..\VERSION pamhyr\_internal
+copy /y ..\AUTHORS pamhyr\_internal
+copy /y ..\LICENSE pamhyr\_internal
+copy /y ..\src\motd.txt pamhyr\_internal

 rem MAGE
-mkdir pamhyr\mage
-copy /y ..\mage-windows\mage.exe pamhyr\mage\
-copy /y ..\mage-windows\mage_extraire.exe pamhyr\mage\
-copy /y ..\mage-windows\mailleurTT.exe pamhyr\mage\
-copy /y ..\mage-windows\libbief.dll pamhyr\mage\
+mkdir pamhyr\mage8
+copy /y ..\mage8-windows\mage.exe pamhyr\mage8\
+copy /y ..\mage8-windows\mage_as7.exe pamhyr\mage8\
+copy /y ..\mage8-windows\mage_extraire.exe pamhyr\mage8\
+copy /y ..\mage8-windows\mailleurTT.exe pamhyr\mage8\
+copy /y ..\mage8-windows\libbief.dll pamhyr\mage8\

 rem Copy tests_cases
 mkdir pamhyr\tests_cases
@@ -3,9 +3,10 @@
 !define LIC_NAME "LICENSE"
 !define APP_NAME "PAMHYR"

+Icon "pamhyr\_internal\View\ui\ressources\icon.ico"
 Name "Pamhyr2"
 OutFile "pamhyr-windows.exe"
-LicenseData "pamhyr\pamhyr\_internal\LICENSE"
+LicenseData "pamhyr\_internal\LICENSE"
 LicenseText "I Agree"

 RequestExecutionLevel admin
@@ -41,12 +42,12 @@ SectionEnd
 Section "Start Menu Shortcuts"
  CreateDirectory "$SMPROGRAMS\Pamhyr2"
  CreateShortcut "$SMPROGRAMS\Pamhyr2\Uninstall.lnk" "$INSTDIR\uninstall.exe"
-  CreateShortcut "$SMPROGRAMS\Pamhyr2\Pamhyr2.lnk" "$INSTDIR\pamhyr\pamhyr.exe"
+  CreateShortcut "$SMPROGRAMS\Pamhyr2\Pamhyr2.lnk" "$INSTDIR\pamhyr.exe"
 SectionEnd

 Section "Desktop Shortcuts"
  SetShellVarContext all
-  CreateShortcut "$desktop\Pamhyr2.lnk" "$instdir\pamhyr\pamhyr.exe"
+  CreateShortcut "$desktop\Pamhyr2.lnk" "$instdir\pamhyr.exe"
 SectionEnd

 Section "Uninstall"
@@ -10,3 +10,5 @@ colorama>=0.4.3
 pyinstaller>=5.11.0
 shapely>=2.0.1
 lxml>=4.9.3
+platformdirs>=4.2.0
+pyshp>=2.3.1
@@ -16,23 +16,53 @@

 # -*- coding: utf-8 -*-

+import logging
+
 from enum import Enum

+from Modules import Modules
 from Model.Except import NotImplementedMethodeError

+logger = logging.getLogger()
+

 class STATUS(Enum):
-    UNKNOWN = -1
    OK = 0
    WARNING = 1
    ERROR = 2
+    UNKNOWN = 999
+
+    def __eq__(self, y):
+        return self.value == y.value
+
+    def __gt__(self, y):
+        return self.value > y.value
+
+    def __or__(self, y):
+        v = [self, y]
+        r = self.OK
+
+        if self.UNKNOWN in v:
+            r = self.UNKNOWN
+        if self.ERROR in v:
+            r = self.ERROR
+        if self.WARNING in v:
+            r = self.WARNING
+
+        logger.debug(f"CHECKER: STATUS: {self} | {y} = {r}")
+        return r


 class AbstractModelChecker(object):
    def __init__(self):
        self._name = ""
        self._description = ""
+        self._solver = "study"
+        self._modules = Modules.NONE

+        self.reset()
+
+    def reset(self):
        self._status = STATUS.UNKNOWN
        self._summary = "Unknown"

@@ -62,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):
@@ -23,6 +23,8 @@ from tools import flatten, timer

 from PyQt5.QtCore import QCoreApplication

+from Modules import Modules
+
 from Checker.Checker import AbstractModelChecker, STATUS
 from Checker.Study import StudyGeometryChecker

@@ -30,7 +32,7 @@ _translate = QCoreApplication.translate


 class MageNetworkGraphChecker(AbstractModelChecker):
-    def __init__(self, connectivity=True):
+    def __init__(self, connectivity=True, version="mage8"):
        super(MageNetworkGraphChecker, self).__init__()

        self._mode_conn = connectivity
@@ -44,6 +46,8 @@ class MageNetworkGraphChecker(AbstractModelChecker):
            "Checker", f"Mage network graph {mode} checker")
        self._description = _translate(
            "Checker", "Check if the network graph is valid")
+        self._solver = version
+        self._modules = Modules.NETWORK

    @timer
    def _connectivity(self, summary, status, graph):
@@ -199,15 +203,18 @@ class MageNetworkGraphChecker(AbstractModelChecker):


 class MageGeometryGuideLineChecker(StudyGeometryChecker):
-    def __init__(self):
+    def __init__(self, version="mage8"):
        super(MageGeometryGuideLineChecker, self).__init__()

-        self._name = _translate("Checker", "Mage geometry guide line checker")
+        self._name = _translate("Checker", "Mage geometry guideline checker")
        self._description = _translate(
            "Checker",
-            "Check if exists geometry guide line is correctly defined \
-for each reaches of the study"
+            "Check if exists geometry guidelines are correctly defined \
+for each reach"
        )
+        self._solver = version
+        self._modules = Modules.GEOMETRY
+
        self._reachs = []

    def run(self, study):
@@ -234,7 +241,7 @@ for each reaches of the study"
            for profile in profiles:
                if not profile.has_standard_named_points():
                    self._status = STATUS.WARNING
-                    self._summary = "no_standard_guileline_defined"
+                    self._summary = "no_standard_guideline_defined"
                    return False

        for gl in gls[1:]:
@@ -17,33 +17,34 @@
 # -*- 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 StudyNetworkReachChecker(AbstractModelChecker):
    def __init__(self):
        super(StudyNetworkReachChecker, self).__init__()

-        self._name = _translate("Checker", "Study network reach checker")
+        self._name = _translate("Checker", "Study reach network checker")
        self._description = _translate(
-            "Checker", "Check if exists at least one reach for study")
+            "Checker", "Check if exists at least one reach exists"
+        )
+        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:
@@ -62,7 +63,10 @@ class StudyGeometryChecker(AbstractModelChecker):

        self._name = _translate("Checker", "Study geometry checker")
        self._description = _translate(
-            "Checker", "Check if exists geometry for each reach of study")
+            "Checker", "Check if the geometry of each reach exists"
+        )
+        self._modules = Modules.GEOMETRY
+
        self._reachs = []

    def run(self, study):
@@ -71,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:
@@ -100,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__()
@@ -30,7 +30,7 @@ from ctypes import (
 )
 from PyQt5.QtCore import QProcess

-from tools import logger_color_red, logger_color_reset
+from tools import logger_color_red, logger_color_reset, logger_exception
 from Meshing.AMeshingTool import AMeshingTool

 logger = logging.getLogger()
@@ -278,7 +278,7 @@ class MeshingWithMageMailleurTT(AMeshingTool):
        return os.path.abspath(
            os.path.join(
                os.path.dirname(__file__),
-                "..", "..", "..", "mage", f"mailleurTT{ext}"
+                "..", "..", "mage8", f"mailleurTT{ext}"
            )
        )

@@ -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

@@ -308,37 +310,133 @@ class MeshingWithMageMailleurTT(AMeshingTool):
            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"! mailleurTT {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()

-            errors = proc.readAllStandardError()
-            if len(errors) != 0:
+            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()}"
                )
-            else:
-                self.import_m_file(reach, m_file)
+                return reach
+
+            self.import_m_file(reach, m_file)
+            return reach
+
+    def update_rk(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,
+                  orientation=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_rk " +
+                f"{str(step)} " +
+                f"{limites[0]} {limites[1]} " +
+                f"{directrices[0]} {directrices[1]} " +
+                f"{orientation} {lm} {linear} " +
+                f"{origin} "
+            )
+            proc.start(
+                self._exe_path(),
+                list(
+                    map(
+                        str,
+                        [
+                            st_file, m_file,
+                            "update_rk", step,
+                            limites[0], limites[1],
+                            directrices[0], directrices[1],
+                            orientation, 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):
@@ -350,7 +448,9 @@ class MeshingWithMageMailleurTT(AMeshingTool):
        return tmp_st

    def import_m_file(self, reach, m):
-        reach.purge()
-
-        logger.debug(f"meshing: Import geometry from {m}")
-        reach.import_geometry(m)
+        if os.path.exists(m):
+            reach.purge()
+            logger.debug(f"meshing: Import geometry from {m}")
+            reach.import_geometry(m)
+        else:
+            logger.error(f"meshing: Meshed geometry file {m} do not exists")
@@ -25,9 +25,10 @@ from Model.Saved import SavedStatus
 from Model.Study import Study
 from Model.River import River

-from Meshing.Mage import MeshingWithMage
+from Meshing.Mage import MeshingWithMage, MeshingWithMageMailleurTT

 mage_mesher = os.path.exists(MeshingWithMage._lib_path())
+mage_mesher_TT = os.path.exists(MeshingWithMageMailleurTT._exe_path())


 class MeshingTestCase(unittest.TestCase):
@@ -35,3 +36,8 @@ class MeshingTestCase(unittest.TestCase):
    def test_create_meshingtool_mage(self):
        mesher = MeshingWithMage()
        self.assertNotEqual(mesher, None)
+
+    @unittest.skipIf(not mage_mesher_TT, "mailleurTT is not available")
+    def test_create_meshingtool_mageTT(self):
+        mesher = MeshingWithMageMailleurTT()
+        self.assertNotEqual(mesher, None)
@@ -0,0 +1,178 @@
+# AddFile.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 functools import reduce
+
+from tools import trace, timer
+
+from Model.Tools.PamhyrDB import SQLSubModel
+from Model.Except import NotImplementedMethodeError
+
+
+class AddFile(SQLSubModel):
+    _sub_classes = []
+    _id_cnt = 0
+
+    def __init__(self, id: int = -1, enabled=True,
+                 name="", path="", text="",
+                 status=None):
+        super(AddFile, self).__init__()
+
+        if id == -1:
+            self.id = AddFile._id_cnt
+        else:
+            self.id = id
+
+        self._status = status
+
+        self._enabled = enabled
+        self._name = f"File {self.id}" if name == "" else name
+        self._path = path
+        self._text = text
+
+        AddFile._id_cnt = max(id, AddFile._id_cnt+1)
+
+    def __getitem__(self, key):
+        value = None
+
+        if key == "enabled":
+            value = self._enabled
+        elif key == "name":
+            value = self._name
+        elif key == "path":
+            value = self._path
+        elif key == "text":
+            value = self._text
+
+        return value
+
+    def __setitem__(self, key, value):
+        if key == "enabled":
+            self._enabled = value
+        elif key == "name":
+            self._name = value
+        elif key == "path":
+            self._path = value
+        elif key == "text":
+            self._text = value
+
+        self._status.modified()
+
+    @property
+    def enabled(self):
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, enabled):
+        self._enabled = enabled
+        self._status.modified()
+
+    def is_enabled(self):
+        return self._enabled
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, name):
+        self._name = name
+        self._status.modified()
+
+    @property
+    def path(self):
+        return self._path
+
+    @path.setter
+    def path(self, path):
+        self._path = path
+        self._status.modified()
+
+    @property
+    def text(self):
+        return self._text
+
+    @text.setter
+    def text(self, text):
+        self._text = text
+        self._status.modified()
+
+    @classmethod
+    def _db_create(cls, execute):
+        execute("""
+          CREATE TABLE additional_files(
+            id INTEGER NOT NULL PRIMARY KEY,
+            enabled BOOLEAN NOT NULL,
+            name TEXT NOT NULL,
+            path TEXT NOT NULL,
+            text TEXT 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) < 8:
+                cls._db_create(execute)
+
+        return True
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = []
+
+        table = execute(
+            "SELECT id, enabled, name, path, text " +
+            "FROM additional_files"
+        )
+
+        for row in table:
+            it = iter(row)
+
+            id = next(it)
+            enabled = (next(it) == 1)
+            name = next(it)
+            path = next(it)
+            text = next(it)
+
+            f = cls(
+                id=id, enabled=enabled, name=name, path=path, text=text,
+                status=data['status']
+            )
+
+            new.append(f)
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        sql = (
+            "INSERT INTO " +
+            "additional_files(id, enabled, name, path, text) " +
+            "VALUES (" +
+            f"{self.id}, {self._enabled}, " +
+            f"'{self._db_format(self._name)}', " +
+            f"'{self._db_format(self._path)}', " +
+            f"'{self._db_format(self._text)}'" +
+            ")"
+        )
+        execute(sql)
+
+        return True
@@ -0,0 +1,56 @@
+# AddFileList.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.AdditionalFile.AddFile import AddFile
+
+
+class AddFileList(PamhyrModelList):
+    _sub_classes = [AddFile]
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = cls(status=data["status"])
+
+        new._lst = AddFile._db_load(execute, data)
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        ok = True
+
+        # Delete previous data
+        execute("DELETE FROM additional_files")
+
+        for af in self._lst:
+            ok &= af._db_save(execute, data)
+
+        return ok
+
+    @property
+    def files(self):
+        return self.lst
+
+    def new(self, index):
+        n = AddFile(status=self._status)
+        self.insert(index, n)
+        self._status.modified()
+        return n
@@ -18,7 +18,12 @@

 import logging

-from tools import trace, timer, old_pamhyr_date_to_timestamp
+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
@@ -189,6 +194,10 @@ class BoundaryCondition(SQLSubModel):
    @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:
@@ -306,6 +315,9 @@ class BoundaryCondition(SQLSubModel):
            self._data.sort(reverse=_reverse, key=key)
        self._status.modified()

+    def index(self, bc):
+        self._data.index(bc)
+
    def get_i(self, index):
        return self.data[index]

@@ -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}")
@@ -43,8 +43,8 @@ class Friction(SQLSubModel):

        self._name = name
        self._edge = None
-        self._begin_kp = 0.0
-        self._end_kp = 0.0
+        self._begin_rk = 0.0
+        self._end_rk = 0.0
        self._begin_strickler = None
        self._end_strickler = None

@@ -54,8 +54,8 @@ class Friction(SQLSubModel):
          CREATE TABLE friction(
            id INTEGER NOT NULL PRIMARY KEY,
            ind INTEGER NOT NULL,
-            begin_kp REAL NOT NULL,
-            end_kp REAL NOT NULL,
+            begin_rk REAL NOT NULL,
+            end_rk REAL NOT NULL,
            reach INTEGER NOT NULL,
            begin_strickler INTEGER NOT NULL,
            end_strickler INTEGER NOT NULL,
@@ -69,6 +69,13 @@ class Friction(SQLSubModel):

    @classmethod
    def _db_update(cls, execute, version):
+        major, minor, release = version.strip().split(".")
+        if major == minor == "0":
+            if int(release) < 11:
+                execute("ALTER TABLE friction " +
+                        "RENAME COLUMN begin_kp TO begin_rk")
+                execute("ALTER TABLE friction RENAME COLUMN end_kp TO end_rk")
+
        return True

    @classmethod
@@ -80,7 +87,7 @@ class Friction(SQLSubModel):
        stricklers = data["stricklers"].stricklers

        table = execute(
-            "SELECT id, ind, begin_kp, end_kp, " +
+            "SELECT id, ind, begin_rk, end_rk, " +
            "begin_strickler, end_strickler " +
            f"FROM friction WHERE reach = {reach.id}"
        )
@@ -102,8 +109,8 @@ class Friction(SQLSubModel):
            # Create friction
            sec = cls(status=status)
            sec.edge = reach
-            sec.begin_kp = row[2]
-            sec.end_kp = row[3]
+            sec.begin_rk = row[2]
+            sec.end_rk = row[3]
            sec.begin_strickler = bs
            sec.end_strickler = es

@@ -124,11 +131,11 @@ class Friction(SQLSubModel):

        execute(
            "INSERT INTO " +
-            "friction(id, ind, begin_kp, end_kp, " +
+            "friction(id, ind, begin_rk, end_rk, " +
            "reach, begin_strickler, end_strickler) " +
            "VALUES (" +
            f"{self.id}, {ind}, " +
-            f"{self._begin_kp}, {self._end_kp}, " +
+            f"{self._begin_rk}, {self._end_rk}, " +
            f"{self._edge.id}, " +
            f"{b_s_id}, {e_s_id}" +
            ")"
@@ -157,10 +164,10 @@ class Friction(SQLSubModel):
    def edge(self, edge):
        self._edge = edge
        if (edge is not None and
-            self._begin_kp == 0.0 and
-                self._end_kp == 0.0):
-            self._begin_kp = self._edge.reach.get_kp_min()
-            self._end_kp = self._edge.reach.get_kp_max()
+            self._begin_rk == 0.0 and
+                self._end_rk == 0.0):
+            self._begin_rk = self._edge.reach.get_rk_min()
+            self._end_rk = self._edge.reach.get_rk_max()
        self._status.modified()

    def has_edge(self):
@@ -176,39 +183,47 @@ class Friction(SQLSubModel):
        return self.has_edge() and self.has_coefficient()

    @property
-    def begin_kp(self):
-        return self._begin_kp
+    def begin_rk(self):
+        return self._begin_rk

-    @begin_kp.setter
-    def begin_kp(self, begin_kp):
+    @begin_rk.setter
+    def begin_rk(self, begin_rk):
        if self._edge is None:
-            self._begin_kp = begin_kp
+            self._begin_rk = begin_rk
        else:
-            _min = self._edge.reach.get_kp_min()
-            _max = self._edge.reach.get_kp_max()
+            _min = self._edge.reach.get_rk_min()
+            _max = self._edge.reach.get_rk_max()

-            if _min <= begin_kp <= _max:
-                self._begin_kp = begin_kp
+            if _min <= begin_rk <= _max:
+                self._begin_rk = begin_rk

        self._status.modified()

    @property
-    def end_kp(self):
-        return self._end_kp
+    def end_rk(self):
+        return self._end_rk

-    @end_kp.setter
-    def end_kp(self, end_kp):
+    @end_rk.setter
+    def end_rk(self, end_rk):
        if self._edge is None:
-            self._end_kp = end_kp
+            self._end_rk = end_rk
        else:
-            _min = self._edge.reach.get_kp_min()
-            _max = self._edge.reach.get_kp_max()
+            _min = self._edge.reach.get_rk_min()
+            _max = self._edge.reach.get_rk_max()

-            if _min <= end_kp <= _max:
-                self._end_kp = end_kp
+            if _min <= end_rk <= _max:
+                self._end_rk = end_rk

        self._status.modified()

+    def __contains__(self, rk):
+        return self.contains_rk(rk)
+
+    def contains_rk(self, rk):
+        return (
+            self._begin_rk <= rk <= self._end_rk
+        )
+
    @property
    def begin_strickler(self):
        return self._begin_strickler
@@ -44,7 +44,7 @@ class FrictionList(PamhyrModelList):
            logger.info(f"Update friction TABLE from {version}")
            cls._db_update_0_0_1(execute, version)

-        return True
+        return cls._update_submodel(execute, version)

    @classmethod
    def _db_load(cls, execute, data=None):
@@ -47,7 +47,7 @@ class PointXYZ(Point, SQLSubModel):
            z INTEGER NOT NULL,
            profile INTEGER NOT NULL,
            sl INTEGER,
-            FOREIGN KEY(profile) REFERENCES profileXYZ(id),
+            FOREIGN KEY(profile) REFERENCES geometry_profileXYZ(id),
            FOREIGN KEY(sl) REFERENCES sedimentary_layer(id)
          )
        """)
@@ -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
@@ -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
@@ -30,7 +31,7 @@ class Profile(object):
    _id_cnt = 0

    def __init__(self, id: int = -1, num: int = 0,
-                 kp: float = 0.0, name: str = "",
+                 rk: float = 0.0, name: str = "",
                 code1: int = 0, code2: int = 0,
                 _type: str = "", reach=None,
                 status=None):
@@ -48,7 +49,7 @@ class Profile(object):
        self._num = int(num)
        self._code1 = int(code1)
        self._code2 = int(code2)
-        self._kp = float(kp)
+        self._rk = float(rk)
        self._name = str(name)
        self._reach = reach
        self._sl = None
@@ -135,16 +136,16 @@ class Profile(object):
        return len(self.points)

    @property
-    def kp(self):
+    def rk(self):
        """
        Returns:
            Kilometer point.
        """
-        return self._kp
+        return self._rk

-    @kp.setter
-    def kp(self, value: float):
-        self._kp = float(value)
+    @rk.setter
+    def rk(self, value: float):
+        self._rk = float(value)
        self._status.modified()

    @property
@@ -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)
@@ -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
@@ -40,7 +41,7 @@ class ProfileXYZ(Profile, SQLSubModel):
    def __init__(self,
                 id: int = -1,
                 name: str = "",
-                 kp: float = 0.,
+                 rk: float = 0.,
                 reach=None,
                 num=0,
                 nb_point: int = 0,
@@ -52,7 +53,7 @@ class ProfileXYZ(Profile, SQLSubModel):
            num: The number of this profile
            code1: The interpolation code 1
            code2: The interpolation code 2
-            kp: Kilometer point
+            rk: Kilometer point
            name: The name of profile

        Returns:
@@ -62,7 +63,7 @@ class ProfileXYZ(Profile, SQLSubModel):
            id=id,
            num=num,
            name=name,
-            kp=kp,
+            rk=rk,
            code1=code1, code2=code2,
            _type="XYZ",
            reach=reach,
@@ -77,7 +78,7 @@ class ProfileXYZ(Profile, SQLSubModel):
            ind INTEGER NOT NULL,
            name TEXT,
            reach INTEGER NOT NULL,
-            kp REAL NOT NULL,
+            rk REAL NOT NULL,
            num INTEGER NOT NULL,
            code1 INTEGER NOT NULL,
            code2 INTEGER NOT NULL,
@@ -93,7 +94,8 @@ class ProfileXYZ(Profile, SQLSubModel):
    def _db_update(cls, execute, version):
        major, minor, release = version.strip().split(".")
        if major == minor == "0":
-            if int(release) < 2:
+            rl = int(release)
+            if rl < 2:
                execute(
                    """
                    ALTER TABLE geometry_profileXYZ
@@ -102,6 +104,14 @@ class ProfileXYZ(Profile, SQLSubModel):
                    """
                )

+            if rl < 11:
+                execute(
+                    """
+                    ALTER TABLE geometry_profileXYZ
+                    RENAME COLUMN kp TO rk
+                    """
+                )
+
        return cls._update_submodel(execute, version)

    @classmethod
@@ -111,7 +121,7 @@ class ProfileXYZ(Profile, SQLSubModel):
        reach = data["reach"]

        table = execute(
-            "SELECT id, ind, name, kp, num, code1, code2, sl " +
+            "SELECT id, ind, name, rk, num, code1, code2, sl " +
            "FROM geometry_profileXYZ " +
            f"WHERE reach = {reach.id}"
        )
@@ -120,7 +130,7 @@ class ProfileXYZ(Profile, SQLSubModel):
            id = row[0]
            ind = row[1]
            name = row[2]
-            kp = row[3]
+            rk = row[3]
            num = row[5]
            code1 = row[5]
            code2 = row[6]
@@ -128,7 +138,7 @@ class ProfileXYZ(Profile, SQLSubModel):

            new = cls(
                id=id, num=num,
-                name=name, kp=kp,
+                name=name, rk=rk,
                code1=code1, code2=code2,
                reach=reach,
                status=status
@@ -158,10 +168,10 @@ class ProfileXYZ(Profile, SQLSubModel):
        sql = (
            "INSERT OR REPLACE INTO " +
            "geometry_profileXYZ(id, ind, name, reach, " +
-            "kp, num, code1, code2, sl) " +
+            "rk, num, code1, code2, sl) " +
            "VALUES (" +
            f"{self.id}, {ind}, '{self._db_format(self._name)}', " +
-            f"{self.reach.id}, {self.kp}, {self.num}, " +
+            f"{self.reach.id}, {self.rk}, {self.num}, " +
            f"{self.code1}, {self.code1}, {sl}" +
            ")"
        )
@@ -186,19 +196,19 @@ class ProfileXYZ(Profile, SQLSubModel):
        try:
            if len(header) == 0:
                name = data[0]
-                kp = data[1]
+                rk = data[1]
                reach = data[2]
                status = data[3]

                profile = cls(
                    id=-1,
                    name=name,
-                    kp=kp,
+                    rk=rk,
                    reach=reach,
                    status=status
                )
            else:
-                valid_header = {'name', 'reach', 'kp', 'status'}
+                valid_header = {'name', 'reach', 'rk', 'status'}
                d = {}
                for i, v in enumerate(data):
                    h = header[i].strip().lower().split(' ')[0]
@@ -322,7 +332,7 @@ class ProfileXYZ(Profile, SQLSubModel):
            logger.debug(f"{e}")
            raise IndexError(
                f"Invalid point name: {name} " +
-                f"for profile ({self.id}) kp = {self.kp}"
+                f"for profile ({self.id}) rk = {self.rk}"
            )

    def has_standard_named_points(self):
@@ -373,99 +383,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 +401,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 +469,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 +485,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)
+                    )
@@ -16,7 +16,9 @@

 # -*- coding: utf-8 -*-

+import os
 import logging
+import shapefile
 import numpy as np

 from time import time
@@ -65,7 +67,7 @@ class Reach(SQLSubModel):

        new._profiles = ProfileXYZ._db_load(
            execute,
-            data=data
+            data=data.copy()
        )

        return new
@@ -111,7 +113,7 @@ class Reach(SQLSubModel):
    def _get_profiles_list(self):
        # Profiles list generator is type (int, Point) with the first
        # element the index of the Point in list
-        logger.info(f"Load profiles from reach {self.name}")
+        logger.debug(f"Load profiles from reach {self.name}")
        return list(
            map(
                lambda p: p[1],
@@ -139,10 +141,10 @@ class Reach(SQLSubModel):
    def profiles(self, profiles):
        self._profiles = profiles

-    def get_profiles_from_kp(self, kp):
+    def get_profiles_from_rk(self, rk):
        return list(
            filter(
-                lambda p: p.kp == kp, self.profiles
+                lambda p: p.rk == rk, self.profiles
            )
        )

@@ -333,18 +335,18 @@ class Reach(SQLSubModel):
            )
        )

-    def get_kp(self):
-        """List of profiles kp
+    def get_rk(self):
+        """List of profiles rk

        Returns:
-            List of profiles kp
+            List of profiles rk
        """
-        return [profile.kp for profile in self.profiles]
+        return [profile.rk for profile in self.profiles]

-    def get_kp_complete_profiles(self):
+    def get_rk_complete_profiles(self):
        return list(
            map(
-                lambda profile: profile.kp,
+                lambda profile: profile.rk,
                filter(
                    lambda profile: len(profile) > 0,
                    self.profiles
@@ -352,18 +354,42 @@ class Reach(SQLSubModel):
            )
        )

-    def get_kp_min(self):
-        if len(self.get_kp()) > 0:
-            return min(self.get_kp())
+    def get_rk_min(self):
+        if len(self.get_rk()) > 0:
+            return min(self.get_rk())
        else:
            return 0.0

-    def get_kp_max(self):
-        if len(self.get_kp()) > 0:
-            return max(self.get_kp())
+    def get_rk_max(self):
+        if len(self.get_rk()) > 0:
+            return max(self.get_rk())
        else:
            return 0.0

+    def inter_profiles_rk(self):
+        profiles = sorted(self.profiles, key=lambda p: p.rk)
+        first = profiles[0]
+        last = profiles[-1]
+
+        res_rk = [first.rk]
+
+        profiles = iter(profiles)
+        previous = next(profiles)
+
+        for profile in profiles:
+            prev = previous.rk
+            curr = profile.rk
+
+            diff = abs(previous.rk - profile.rk)
+
+            new = previous.rk + (diff / 2.0)
+            res_rk.append(new)
+
+            previous = profile
+
+        res_rk.append(last.rk)
+        return res_rk
+
    # Sediment Layers

    def get_sl(self):
@@ -510,7 +536,7 @@ class Reach(SQLSubModel):
    def sort(self, is_reversed: bool = False):
        self.profiles = sorted(
            self.profiles,
-            key=lambda profile: profile.kp,
+            key=lambda profile: profile.rk,
            reverse=is_reversed
        )
        self._status.modified()
@@ -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_rk()
+
+        return profiles
+
+    @timer
+    def import_geometry_st(self, file_path_name: str):
        """Import a geometry from file (.ST or .st)

        Args:
@@ -549,7 +633,7 @@ class Reach(SQLSubModel):
        try:
            list_profile, list_header = self.read_file_st(str(file_path_name))
            profile_header = ["num", "code1",
-                              "code2", "nb_point", "kp", "name"]
+                              "code2", "nb_point", "rk", "name"]

            if list_profile and list_header:
                for ind, profile in enumerate(list_profile):
@@ -637,12 +721,12 @@ class Reach(SQLSubModel):
                c1 = f"{profile.code1:>6}"
                c2 = f"{profile.code2:>6}"
                t = f"{len(profile.points):>6}"
-                kp = f"{profile.kp:>12f}"[0:12]
+                rk = f"{profile.rk:>12f}"[0:12]
                pname = profile.name
                if profile.name == "":
                    pname = f"p{profile.id:>3}".replace(" ", "0")

-                st.write(f"{num}{c1}{c2}{t} {kp} {pname}\n")
+                st.write(f"{num}{c1}{c2}{t} {rk} {pname}\n")

                for point in profile.points:
                    x = f"{point.x:<12.4f}"[0:12]
@@ -661,15 +745,15 @@ class Reach(SQLSubModel):
        last = self.profile(len(self) - 1)

        z_first = first.z_min()
-        kp_first = first.kp
+        rk_first = first.rk

        z_last = last.z_min()
-        kp_last = last.kp
+        rk_last = last.rk

        return (
            (z_last - z_first)
            /
-            (kp_last - kp_first)
+            (rk_last - rk_first)
        )

    def get_incline_mean(self):
@@ -680,15 +764,15 @@ class Reach(SQLSubModel):

        for profile in profiles[1:]:
            z_first = previous.z_min()
-            kp_first = previous.kp
+            rk_first = previous.rk

            z_last = profile.z_min()
-            kp_last = profile.kp
+            rk_last = profile.rk

            incline_acc += (
                (z_last - z_first)
                /
-                (kp_last - kp_first)
+                (rk_last - rk_first)
            )

            previous = profile
@@ -703,15 +787,15 @@ class Reach(SQLSubModel):

        for profile in profiles[1:]:
            z_first = previous.z_min()
-            kp_first = previous.kp
+            rk_first = previous.rk

            z_last = profile.z_min()
-            kp_last = profile.kp
+            rk_last = profile.rk

            incline_acc += [
                (z_last - z_first)
                /
-                (kp_last - kp_first)
+                (rk_last - rk_first)
            ]

            previous = profile
@@ -727,15 +811,15 @@ class Reach(SQLSubModel):

        for profile in profiles[1:]:
            z_first = previous.z_min()
-            kp_first = previous.kp
+            rk_first = previous.rk

            z_last = profile.z_min()
-            kp_last = profile.kp
+            rk_last = profile.rk

            incline_acc += [
                (z_last - z_first)
                /
-                (kp_last - kp_first)
+                (rk_last - rk_first)
            ]

            previous = profile
@@ -743,7 +827,10 @@ class Reach(SQLSubModel):
        incline_acc.sort()

        marge = round(len(incline_acc) * 0.1)
-        incline_set = incline_acc[marge:-marge]
+        if marge > 0:
+            incline_set = incline_acc[marge:-marge]
+        else:
+            incline_set = incline_acc

        logger.debug(f"+{incline_acc}")
        logger.debug(f"-{incline_set}")
@@ -759,3 +846,24 @@ class Reach(SQLSubModel):
        except Exception as e:
            logger_exception(e)
            return 0
+
+    def _recompute_rk(self, offset=0.0):
+        self._recompute_rk_no_gl(offset=offset)
+
+    def _recompute_rk_no_gl(self, offset=0.0):
+        profiles = iter(self.profiles)
+
+        previous = next(profiles)
+        previous.rk = 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.rk = previous.rk + dist
+            previous = profile
@@ -50,8 +50,8 @@ class HydraulicStructure(SQLSubModel):
            self.id = id

        self._name = name
-        self._input_kp = None
-        self._output_kp = None
+        self._input_rk = None
+        self._output_rk = None
        self._input_reach = None
        self._output_reach = None
        self._enabled = True
@@ -69,8 +69,8 @@ class HydraulicStructure(SQLSubModel):
            id INTEGER NOT NULL PRIMARY KEY,
            name TEXT NOT NULL,
            enabled BOOLEAN NOT NULL,
-            input_kp REAL NOT NULL,
-            output_kp REAL NOT NULL,
+            input_rk REAL NOT NULL,
+            output_rk REAL NOT NULL,
            input_reach INTEGER,
            output_reach INTEGER,
            FOREIGN KEY(input_reach) REFERENCES river_reach(id),
@@ -84,9 +84,25 @@ class HydraulicStructure(SQLSubModel):
    def _db_update(cls, execute, version):
        major, minor, release = version.strip().split(".")
        if major == minor == "0":
-            if int(release) < 6:
+            rl = int(release)
+
+            if rl < 6:
                cls._db_create(execute)

+            if rl < 11:
+                execute(
+                    """
+                    ALTER TABLE hydraulic_structures
+                    RENAME COLUMN input_kp TO input_rk
+                    """
+                )
+                execute(
+                    """
+                    ALTER TABLE hydraulic_structures
+                    RENAME COLUMN output_kp TO output_rk
+                    """
+                )
+
        return True

    @classmethod
@@ -95,7 +111,7 @@ class HydraulicStructure(SQLSubModel):

        table = execute(
            "SELECT id, name, enabled, " +
-            "input_kp, output_kp, " +
+            "input_rk, output_rk, " +
            "input_reach, output_reach " +
            "FROM hydraulic_structures "
        )
@@ -106,8 +122,8 @@ class HydraulicStructure(SQLSubModel):
            hs_id = next(it)
            name = next(it)
            enabled = (next(it) == 1)
-            input_kp = next(it)
-            output_kp = next(it)
+            input_rk = next(it)
+            output_rk = next(it)
            input_reach_id = next(it)
            output_reach_id = next(it)

@@ -118,8 +134,8 @@ class HydraulicStructure(SQLSubModel):
            )

            hs.enabled = enabled
-            hs.input_kp = input_kp if input_kp != -1 else None
-            hs.output_kp = output_kp if output_kp != -1 else None
+            hs.input_rk = input_rk if input_rk != -1 else None
+            hs.output_rk = output_rk if output_rk != -1 else None

            hs.input_reach, hs.output_reach = reduce(
                lambda acc, n: (
@@ -148,24 +164,24 @@ class HydraulicStructure(SQLSubModel):
        if self._output_reach is not None:
            output_reach_id = self._output_reach.id

-        input_kp = -1
-        if self.input_kp is not None:
-            input_kp = self.input_kp
+        input_rk = -1
+        if self.input_rk is not None:
+            input_rk = self.input_rk

-        output_kp = -1
-        if self.output_kp is not None:
-            output_kp = self.output_kp
+        output_rk = -1
+        if self.output_rk is not None:
+            output_rk = self.output_rk

        sql = (
            "INSERT INTO " +
            "hydraulic_structures(" +
-            "  id, name, enabled, input_kp, output_kp, " +
+            "  id, name, enabled, input_rk, output_rk, " +
            "  input_reach, output_reach" +
            ") " +
            "VALUES (" +
            f"{self.id}, '{self._db_format(self._name)}', " +
            f"{self._db_format(self.enabled)}, " +
-            f"{input_kp}, {output_kp}, " +
+            f"{input_rk}, {output_rk}, " +
            f"{input_reach_id}, {output_reach_id}" +
            ")"
        )
@@ -198,24 +214,24 @@ class HydraulicStructure(SQLSubModel):
        self._status.modified()

    @property
-    def input_kp(self):
-        return self._input_kp
+    def input_rk(self):
+        return self._input_rk

-    @input_kp.setter
-    def input_kp(self, input_kp):
-        if input_kp is not None:
-            input_kp = float(input_kp)
+    @input_rk.setter
+    def input_rk(self, input_rk):
+        if input_rk is not None:
+            input_rk = float(input_rk)

-        self._input_kp = input_kp
+        self._input_rk = input_rk
        self._status.modified()

    @property
-    def output_kp(self):
-        return self._output_kp
+    def output_rk(self):
+        return self._output_rk

-    @output_kp.setter
-    def output_kp(self, output_kp):
-        self._output_kp = output_kp
+    @output_rk.setter
+    def output_rk(self, output_rk):
+        self._output_rk = output_rk
        self._status.modified()

    @property
@@ -30,7 +30,7 @@ logger = logging.getLogger()
 class Data(SQLSubModel):
    def __init__(self, name: str = "",
                 comment: str = "", reach=None,
-                 kp: float = 0.0, discharge: float = 0.0,
+                 rk: float = 0.0, discharge: float = 0.0,
                 height: float = 0.0,
                 status=None):
        super(Data, self).__init__()
@@ -42,14 +42,14 @@ class Data(SQLSubModel):
        self._name = name
        self._comment = comment

-        self._kp = kp
+        self._rk = rk
        self._discharge = discharge
        self._speed = 0.0
        self._elevation = 0.0
        self._height = height

-        if self._kp != 0.0:
-            self._update_from_kp()
+        if self._rk != 0.0:
+            self._update_from_rk()
        if self._height != 0.0:
            self._update_from_height()
        if self._discharge != 0.0:
@@ -64,7 +64,7 @@ class Data(SQLSubModel):
            name TEXT NOT NULL,
            comment TEXT NOT NULL,
            reach INTEGER,
-            kp REAL NOT NULL,
+            rk REAL NOT NULL,
            discharge REAL NOT NULL,
            height REAL NOT NULL,
            FOREIGN KEY(reach) REFERENCES river_reach(id)
@@ -75,13 +75,20 @@ class Data(SQLSubModel):

    @classmethod
    def _db_update(cls, execute, version):
+        major, minor, release = version.strip().split(".")
+        if major == minor == "0":
+            if int(release) < 11:
+                execute(
+                    "ALTER TABLE initial_conditions RENAME COLUMN kp TO rk"
+                )
+
        return cls._update_submodel(execute, version)

    @classmethod
    def _db_load(cls, execute, data=None):
        id = data["reach"].id
        table = execute(
-            "SELECT ind, name, comment, kp, discharge, height " +
+            "SELECT ind, name, comment, rk, discharge, height " +
            "FROM initial_conditions " +
            f"WHERE reach = {id}"
        )
@@ -95,7 +102,7 @@ class Data(SQLSubModel):
            ind = row[0]
            name = row[1]
            comment = row[2]
-            kp = row[3]
+            rk = row[3]
            discharge = row[4]
            height = row[5]

@@ -104,7 +111,7 @@ class Data(SQLSubModel):
                status=data["status"],
                name=name,
                comment=comment,
-                kp=kp,
+                rk=rk,
                discharge=discharge,
                height=height,
            )
@@ -118,12 +125,12 @@ class Data(SQLSubModel):

        execute(
            "INSERT INTO " +
-            "initial_conditions(ind, name, comment, kp, " +
+            "initial_conditions(ind, name, comment, rk, " +
            "discharge, height, reach) " +
            "VALUES (" +
            f"{ind}, '{self._db_format(self.name)}', " +
            f"'{self._db_format(self._comment)}', " +
-            f"{self._kp}, {self._discharge}, {self._height}, " +
+            f"{self._rk}, {self._discharge}, {self._height}, " +
            f"{self._reach.id}" +
            ")"
        )
@@ -134,13 +141,12 @@ class Data(SQLSubModel):
        new = Data(
            name=self.name,
            comment=self._comment,
-            kp=self._kp,
+            rk=self._rk,
            discharge=self._discharge,
            height=self._height,
            reach=self._reach,
            status=self._status,
        )
-
        return new

    @property
@@ -154,8 +160,8 @@ class Data(SQLSubModel):
            val = self._name
        elif key == "comment":
            val = self._comment
-        elif key == "kp":
-            val = self._kp
+        elif key == "rk":
+            val = self._rk
        elif key == "speed":
            val = self._speed
        elif key == "discharge":
@@ -168,7 +174,7 @@ class Data(SQLSubModel):
        return val

    def _update_get_min(self):
-        profile = self._reach.reach.get_profiles_from_kp(self._kp)
+        profile = self._reach.reach.get_profiles_from_rk(self._rk)
        if len(profile) > 0:
            min = profile[0].z_min()
        else:
@@ -176,7 +182,7 @@ class Data(SQLSubModel):

        return min

-    def _update_from_kp(self):
+    def _update_from_rk(self):
        min = self._update_get_min()
        self._elevation = min + self._height

@@ -197,9 +203,9 @@ class Data(SQLSubModel):
            self._name = str(value)
        elif key == "comment":
            self._comment = str(value)
-        elif key == "kp":
-            self._kp = float(value)
-            self._update_from_kp()
+        elif key == "rk":
+            self._rk = float(value)
+            self._update_from_rk()
        elif key == "speed":
            # Not supposed to be modified
            self._speed = float(value)
@@ -266,6 +272,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 +304,15 @@ class InitialConditions(SQLSubModel):
        self._data.insert(index, n)
        self._status.modified()

+    def new_from_data(self, rk, discharge, elevation):
+        n = Data(reach=self._reach, status=self._status)
+
+        n['rk'] = rk
+        n['discharge'] = discharge
+        n['elevation'] = elevation
+
+        return n
+
    def insert(self, index, data):
        self._data.insert(index, data)
        self._status.modified()
@@ -332,8 +350,8 @@ class InitialConditions(SQLSubModel):
            )
        )

-    def get_kp(self):
-        return self._data_get("kp")
+    def get_rk(self):
+        return self._data_get("rk")

    def get_elevation(self):
        return self._data_get("elevation")
@@ -341,10 +359,10 @@ class InitialConditions(SQLSubModel):
    def get_discharge(self):
        return self._data_get("discharge")

-    def _sort_by_z_and_kp(self, profiles):
+    def _sort_by_z_and_rk(self, profiles):
        profiles.sort(
            reverse=False,
-            key=lambda p: p.kp
+            key=lambda p: p.rk
        )

        first_z = profiles[0].z()
@@ -353,87 +371,107 @@ class InitialConditions(SQLSubModel):
        if first_z > last_z:
            profiles.sort(
                reverse=True,
-                key=lambda p: p.kp
+                key=lambda p: p.rk
            )

-    def generate_growing_constante_height(self, height: float):
-        self._data = []
+    def generate_growing_constante_height(self, height: float,
+                                          compute_discharge: bool):

        profiles = self._reach.reach.profiles.copy()
-        self._sort_by_z_and_kp(profiles)
+        self._sort_by_z_and_rk(profiles)
+
+        previous_elevation = -99999.99
+
+        data_discharge = {}
+        if not compute_discharge:
+            if len(self._data) == 0:
+                for profile in profiles:
+                    data_discharge[profile.rk] = 0.0
+            else:
+                for data in self._data:
+                    data_discharge[data["rk"]] = data["discharge"]

        incline = self._reach.reach.get_incline_median_mean()
        logger.debug(f"incline = {incline}")
-
-        previous_elevation = -99999.99
+        self._data = []
        for profile in profiles:
            width = profile.width_approximation()
            strickler = 25
-            discharge = (
-                ((width * 0.8)
-                 * strickler
-                 * (height ** (5/3))
-                 * (abs(incline) ** (0.5)))
-            )
+
+            if not compute_discharge:
+                discharge = data_discharge[profile.rk]
+            else:
+                discharge = (
+                    ((width * 0.8)
+                     * strickler
+                     * (height ** (5/3))
+                     * (abs(incline) ** (0.5)))
+                )

            elevation = max(
                profile.z_min() + height,
                previous_elevation
            )

-            logger.debug(f"({profile.kp}):")
+            logger.debug(f"({profile.rk}):")
            logger.debug(f"  width  = {width}")
            logger.debug(f"  strickler = {strickler}")
            logger.debug(f"  discharge = {discharge}")

            new = Data(reach=self._reach, status=self._status)
-            new["kp"] = profile.kp
+            new["rk"] = profile.rk
            new["discharge"] = discharge
-
            new["elevation"] = elevation

-            self._data.append(new)
            previous_elevation = elevation
+            self._data.append(new)

        self._generate_resort_data(profiles)

-    def generate_discharge(self, discharge: float):
-        self._data = []
+    def generate_discharge(self, discharge: float, compute_height: bool):

-        self._generate_height_estimation_from_discharge(
-            discharge
-        )
-
-    def _generate_height_estimation_from_discharge(self, discharge: float):
        profiles = self._reach.reach.profiles.copy()
-        self._sort_by_z_and_kp(profiles)
+        self._sort_by_z_and_rk(profiles)

        previous_elevation = -99999.99

+        data_height = {}
+        if not compute_height:
+            if len(self._data) == 0:
+                for profile in profiles:
+                    data_height[profile.rk] = 0.0
+            else:
+                for data in self._data:
+                    data_height[data["rk"]] = data["height"]
+
        incline = self._reach.reach.get_incline_median_mean()
        logger.debug(f"incline = {incline}")
-
+        self._data = []
        for profile in profiles:
            width = profile.width_approximation()
            strickler = 25
-            height = (
-                discharge
-                /
-                ((width * 0.8) * strickler * (abs(incline) ** (0.5)))
-            ) ** (0.6)
+
+            if not compute_height:
+                height = data_height[profile.rk]
+            else:
+                height = (
+                    discharge
+                    /
+                    ((width * 0.8) * strickler * (abs(incline) ** (0.5)))
+                ) ** (0.6)

            elevation = max(
                profile.z_min() + height,
                previous_elevation
            )

-            logger.debug(f"({profile.kp}):")
+            logger.debug(f"({profile.rk}):")
            logger.debug(f"  width  = {width}")
            logger.debug(f"  strickler = {strickler}")
-            logger.debug(f"  hieght = {height}")
+            logger.debug(f"  height = {height}")

            new = Data(reach=self._reach, status=self._status)
-            new["kp"] = profile.kp
+            new["rk"] = profile.rk
            new["discharge"] = discharge
            new["elevation"] = elevation

@@ -444,10 +482,10 @@ class InitialConditions(SQLSubModel):

    def _generate_resort_data(self, profiles):
        is_reverse = False
-        if profiles[0].kp > profiles[-1].kp:
+        if profiles[0].rk > profiles[-1].rk:
            is_reverse = True

        self._data.sort(
            reverse=not is_reverse,
-            key=lambda d: d['kp']
+            key=lambda d: d['rk']
        )
@@ -18,7 +18,12 @@

 import logging

-from tools import trace, timer, old_pamhyr_date_to_timestamp
+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
@@ -43,8 +48,8 @@ class LateralContribution(SQLSubModel):
        self._name = name
        self._type = ""
        self._edge = None
-        self._begin_kp = 0.0
-        self._end_kp = 0.0
+        self._begin_rk = 0.0
+        self._end_rk = 0.0
        self._data = []
        self._header = []
        self._types = [float, float]
@@ -61,8 +66,8 @@ class LateralContribution(SQLSubModel):
            type TEXT NOT NULL,
            tab TEXT NOT NULL,
            edge INTEGER,
-            begin_kp REAL NOT NULL,
-            end_kp REAL NOT NULL,
+            begin_rk REAL NOT NULL,
+            end_rk REAL NOT NULL,
            FOREIGN KEY(edge) REFERENCES river_reach(id)
          )
        """)
@@ -82,6 +87,22 @@ class LateralContribution(SQLSubModel):

    @classmethod
    def _db_update(cls, execute, version):
+        major, minor, release = version.strip().split(".")
+        if major == minor == "0":
+            if int(release) < 11:
+                execute(
+                    """
+                    ALTER TABLE lateral_contribution
+                    RENAME COLUMN begin_kp TO begin_rk
+                    """
+                )
+                execute(
+                    """
+                    ALTER TABLE lateral_contribution
+                    RENAME COLUMN end_kp TO end_rk
+                    """
+                )
+
        return True

    @classmethod
@@ -105,7 +126,7 @@ class LateralContribution(SQLSubModel):
        tab = data["tab"]

        table = execute(
-            "SELECT id, name, type, edge, begin_kp, end_kp " +
+            "SELECT id, name, type, edge, begin_rk, end_rk " +
            f"FROM lateral_contribution WHERE tab = '{tab}'"
        )

@@ -120,8 +141,8 @@ class LateralContribution(SQLSubModel):
            lc.edge = None
            if row[3] != -1:
                lc.edge = next(filter(lambda e: e.id == row[3], data["edges"]))
-            lc._begin_kp = row[4]
-            lc._end_kp = row[5]
+            lc._begin_rk = row[4]
+            lc._end_rk = row[5]

            values = execute(
                "SELECT ind, data0, data1 FROM lateral_contribution_data " +
@@ -155,11 +176,11 @@ class LateralContribution(SQLSubModel):
        sql = (
            "INSERT INTO " +
            "lateral_contribution(id, name, type, tab, " +
-            "edge, begin_kp, end_kp) " +
+            "edge, begin_rk, end_rk) " +
            "VALUES (" +
            f"{self.id}, '{self._db_format(self._name)}', " +
            f"'{self._db_format(self._type)}', '{tab}', {edge}, " +
-            f"{self._begin_kp}, {self._end_kp}" +
+            f"{self._begin_rk}, {self._end_rk}" +
            ")"
        )
        execute(sql)
@@ -189,6 +210,10 @@ class LateralContribution(SQLSubModel):
    @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:
@@ -222,44 +247,44 @@ class LateralContribution(SQLSubModel):
    def edge(self, edge):
        self._edge = edge
        if edge is not None:
-            self._begin_kp = self._edge.reach.get_kp_min()
-            self._end_kp = self._edge.reach.get_kp_max()
+            self._begin_rk = self._edge.reach.get_rk_min()
+            self._end_rk = self._edge.reach.get_rk_max()
        self._status.modified()

    def has_edge(self):
        return self._edge is not None

    @property
-    def begin_kp(self):
-        return self._begin_kp
+    def begin_rk(self):
+        return self._begin_rk

-    @begin_kp.setter
-    def begin_kp(self, begin_kp):
+    @begin_rk.setter
+    def begin_rk(self, begin_rk):
        if self._edge is None:
-            self._begin_kp = begin_kp
+            self._begin_rk = begin_rk
        else:
-            _min = self._edge.reach.get_kp_min()
-            _max = self._edge.reach.get_kp_max()
+            _min = self._edge.reach.get_rk_min()
+            _max = self._edge.reach.get_rk_max()

-            if _min <= begin_kp <= _max:
-                self._begin_kp = begin_kp
+            if _min <= begin_rk <= _max:
+                self._begin_rk = begin_rk

        self._status.modified()

    @property
-    def end_kp(self):
-        return self._end_kp
+    def end_rk(self):
+        return self._end_rk

-    @end_kp.setter
-    def end_kp(self, end_kp):
+    @end_rk.setter
+    def end_rk(self, end_rk):
        if self._edge is None:
-            self._end_kp = end_kp
+            self._end_rk = end_rk
        else:
-            _min = self._edge.reach.get_kp_min()
-            _max = self._edge.reach.get_kp_max()
+            _min = self._edge.reach.get_rk_min()
+            _max = self._edge.reach.get_rk_max()

-            if _min <= end_kp <= _max:
-                self._end_kp = end_kp
+            if _min <= end_rk <= _max:
+                self._end_rk = end_rk

        self._status.modified()

@@ -368,8 +393,8 @@ class LateralContribution(SQLSubModel):
    def convert(self, cls):
        new = cls(name=self.name, status=self._status)
        new.edge = self.edge
-        new.begin_kp = self.begin_kp
-        new.end_kp = self.end_kp
+        new.begin_rk = self.begin_rk
+        new.end_rk = self.end_rk

        for i, _ in enumerate(self.data):
            new.add(i)
@@ -67,6 +67,13 @@ class Graph(object):
    def edges_counts(self):
        return len(self._edges)

+    def enable_nodes_counts(self):
+        return reduce(
+            lambda acc, n: acc + 1 if self.is_enable_node(n) else acc,
+            self._nodes,
+            0
+        )
+
    def enable_edges_counts(self):
        return reduce(
            lambda acc, e: acc + 1 if e.is_enable() else acc,
@@ -135,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)
@@ -169,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)

@@ -190,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):
@@ -213,6 +210,12 @@ class Graph(object):
            True
        )

+    def is_internal_node(self, node):
+        return not (
+            self.is_upstream_node(node) or
+            self.is_downstream_node(node)
+        )
+
    def is_enable_node(self, node):
        return reduce(
            lambda acc, e: (
@@ -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)
@@ -0,0 +1,180 @@
+# REPLine.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 functools import reduce
+
+from tools import trace, timer
+
+from Model.Tools.PamhyrDB import SQLSubModel
+from Model.Except import NotImplementedMethodeError
+
+
+class REPLine(SQLSubModel):
+    _sub_classes = []
+    _id_cnt = 0
+
+    def __init__(self, id: int = -1, enabled=True,
+                 name="", line="", solvers=set(),
+                 status=None):
+        super(REPLine, self).__init__()
+
+        if id == -1:
+            self.id = REPLine._id_cnt
+        else:
+            self.id = id
+
+        self._status = status
+
+        self._enabled = enabled
+        self._name = f"Line{self.id}" if name == "" else name
+        self._line = line
+        self._solvers = solvers
+
+        REPLine._id_cnt = max(id, REPLine._id_cnt+1)
+
+    def __getitem__(self, key):
+        value = None
+
+        if key == "enabled":
+            value = self._enabled
+        elif key == "name":
+            value = self._name
+        elif key == "line":
+            value = self._line
+        elif key == "solvers":
+            value = self._solvers
+
+        return value
+
+    def __setitem__(self, key, value):
+        if key == "enabled":
+            self._enabled = value
+        elif key == "name":
+            self._name = value
+        elif key == "line":
+            self._line = value
+        elif key == "solvers":
+            self._solvers = value
+
+        self._status.modified()
+
+    @property
+    def enabled(self):
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, enabled):
+        self._enabled = enabled
+        self._status.modified()
+
+    def is_enabled(self):
+        return self._enabled
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, name):
+        self._name = name
+        self._status.modified()
+
+    @property
+    def line(self):
+        return self._line
+
+    @line.setter
+    def line(self, line):
+        self._line = line
+        self._status.modified()
+
+    @property
+    def solvers(self):
+        return self._solvers
+
+    @solvers.setter
+    def solvers(self, solvers):
+        self._solvers = solvers
+        self._status.modified()
+
+    @classmethod
+    def _db_create(cls, execute):
+        execute("""
+          CREATE TABLE rep_lines(
+            id INTEGER NOT NULL PRIMARY KEY,
+            enabled BOOLEAN NOT NULL,
+            name TEXT NOT NULL,
+            line TEXT NOT NULL,
+            solvers TEXT 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) < 9:
+                cls._db_create(execute)
+
+        return True
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = []
+
+        table = execute(
+            "SELECT id, enabled, name, line, solvers " +
+            "FROM rep_lines"
+        )
+
+        for row in table:
+            it = iter(row)
+
+            id = next(it)
+            enabled = (next(it) == 1)
+            name = next(it)
+            line = next(it)
+            solvers = set(next(it).split(";;"))
+
+            f = cls(
+                id=id, enabled=enabled, name=name, line=line,
+                solvers=solvers, status=data['status']
+            )
+
+            new.append(f)
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        solvers = ";;".join(self._solvers)
+
+        sql = (
+            "INSERT INTO " +
+            "rep_lines(id, enabled, name, line, solvers) " +
+            "VALUES (" +
+            f"{self.id}, {self._enabled}, " +
+            f"'{self._db_format(self._name)}', " +
+            f"'{self._db_format(self._line)}', " +
+            f"'{self._db_format(solvers)}'" +
+            ")"
+        )
+        execute(sql)
+
+        return True
@@ -0,0 +1,56 @@
+# REPLineList.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.REPLine.REPLine import REPLine
+
+
+class REPLineList(PamhyrModelList):
+    _sub_classes = [REPLine]
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = cls(status=data["status"])
+
+        new._lst = REPLine._db_load(execute, data)
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        ok = True
+
+        # Delete previous data
+        execute("DELETE FROM rep_lines")
+
+        for af in self._lst:
+            ok &= af._db_save(execute, data)
+
+        return ok
+
+    @property
+    def lines(self):
+        return self.lst
+
+    def new(self, index):
+        n = REPLine(status=self._status)
+        self.insert(index, n)
+        self._status.modified()
+        return n
@@ -35,8 +35,8 @@ class Profile(object):
        return self._profile.name

    @property
-    def kp(self):
-        return self._profile.kp
+    def rk(self):
+        return self._profile.rk

    @property
    def geometry(self):
@@ -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
+            )
+        )
@@ -40,6 +40,8 @@ from Model.Reservoir.ReservoirList import ReservoirList
 from Model.HydraulicStructures.HydraulicStructuresList import (
    HydraulicStructureList,
 )
+from Model.AdditionalFile.AddFileList import AddFileList
+from Model.REPLine.REPLineList import REPLineList

 from Solver.Solvers import solver_type_list

@@ -224,6 +226,8 @@ class River(Graph, SQLSubModel):
        SedimentLayerList,
        ReservoirList,
        HydraulicStructureList,
+        AddFileList,
+        REPLineList,
    ]

    def __init__(self, status=None):
@@ -245,6 +249,8 @@ class River(Graph, SQLSubModel):
        self._hydraulic_structures = HydraulicStructureList(
            status=self._status
        )
+        self._additional_files = AddFileList(status=self._status)
+        self._rep_lines = REPLineList(status=self._status)

    @classmethod
    def _db_create(cls, execute):
@@ -263,66 +269,62 @@ class River(Graph, SQLSubModel):
        # Stricklers (Stricklers is load in first because it's needed
        # for reachs)
        new._stricklers = StricklersList._db_load(
-            execute,
-            data
+            execute, data
        )
        data["stricklers"] = new._stricklers

        # Initial conditions
        new._sediment_layers = SedimentLayerList._db_load(
-            execute,
-            data
+            execute, data
        )
        data["sediment_layers_list"] = new._sediment_layers

        # Network
        new._nodes = RiverNode._db_load(
-            execute,
-            data
+            execute, data
        )
        data["nodes"] = new.nodes()

        new._edges = RiverReach._db_load(
-            execute,
-            data
+            execute, data
        )
        data["edges"] = new.edges()

        # Boundary Condition
        new._boundary_condition = BoundaryConditionList._db_load(
-            execute,
-            data
+            execute, data
        )
        # Lateral Contribution
        new._lateral_contribution = LateralContributionList._db_load(
-            execute,
-            data
+            execute, data
        )

        # Initial conditions
        new._initial_conditions = InitialConditionsDict._db_load(
-            execute,
-            data
+            execute, data
        )

        # Reservoir
        new._reservoir = ReservoirList._db_load(
-            execute,
-            data
+            execute, data
        )

        # Hydraulic Structures
        new._hydraulic_structures = HydraulicStructureList._db_load(
-            execute,
-            data
+            execute, data
        )

        # Parameters
        new._parameters = SolverParametersList._db_load(
-            execute,
-            data
+            execute, data
        )

+        # Additional Files
+        new._additional_files = AddFileList._db_load(
+            execute, data
+        )
+        new._rep_lines = REPLineList._db_load(execute, data)
+
        return new

    def _db_save(self, execute, data=None):
@@ -336,6 +338,8 @@ class River(Graph, SQLSubModel):
        objs.append(self._stricklers)
        objs.append(self._reservoir)
        objs.append(self._hydraulic_structures)
+        objs.append(self._additional_files)
+        objs.append(self._rep_lines)

        for solver in self._parameters:
            objs.append(self._parameters[solver])
@@ -373,11 +377,42 @@ class River(Graph, SQLSubModel):
            logger_exception(e)

    def init_default(self):
+        self.init_default_network()
+        self.init_default_sediment()
+        self.init_default_additional_files()
+
+    def init_default_network(self):
        n1 = self.add_node(880.0, 950.0)
        n2 = self.add_node(1120.0, 1020.0)

        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"
+        add_file.path = "Pamhyr2.txt"
+        add_file.text = """This repository has been generated by Pamhyr2 \
+version "@version" !
+
+All hand made file modification could be erased by the next solver
+execution...
+
+Last export at: @date."""
+
    @property
    def boundary_condition(self):
        return self._boundary_condition
@@ -419,6 +454,14 @@ class River(Graph, SQLSubModel):
    def hydraulic_structures(self):
        return self._hydraulic_structures

+    @property
+    def additional_files(self):
+        return self._additional_files
+
+    @property
+    def rep_lines(self):
+        return self._rep_lines
+
    @property
    def parameters(self):
        return self._parameters
@@ -22,10 +22,19 @@ logger = logging.getLogger()


 class SavedStatus(object):
-    def __init__(self):
+    def __init__(self, version=0):
        super(SavedStatus, self).__init__()
+        self._version = version
        self._saved = True

+    @property
+    def version(self):
+        return self._version
+
+    @version.setter
+    def version(self, version):
+        self._version = version
+
    def is_saved(self):
        return self._saved

@@ -34,5 +43,11 @@ class SavedStatus(object):
        self._saved = True

    def modified(self):
-        # logger.debug("model status set as modified")
+        if self._saved:
+            self._version += 1
+
+        logger.debug(
+            "STATUS: Model status set as modified " +
+            f"at version {self._version}"
+        )
        self._saved = False
@@ -41,7 +41,7 @@ class Study(SQLModel):

    def __init__(self, filename=None, init_new=True):
        # Metadata
-        self._version = "0.0.7"
+        self._version = "0.0.11"
        self.creation_date = datetime.now()
        self.last_modification_date = datetime.now()
        self.last_save_date = datetime.now()
@@ -71,6 +71,8 @@ class Study(SQLModel):
        lst = [
            StudyNetworkReachChecker(),
            StudyGeometryChecker(),
+            StudyInitialConditionsChecker(),
+            StudyBoundaryConditionChecker(),
            # DummyOK(),
            # DummyWARNING(),
            # DummyERROR(),
@@ -103,10 +105,23 @@ class Study(SQLModel):
            except Exception as e:
                logger.error(e)

+        is_new = False
        fname = fname + "." + str(self._old_save_id)
-        filename = os.path.join(fdir, "_PAMHYR_", "__old__", fname)
-        shutil.copy(self.filename, filename)
-        self._old_save_id += 1
+        if os.path.exists(self.filename) and ".backup" not in self.filename:
+            filename = os.path.join(fdir, "_PAMHYR_", "__old__", fname)
+            logger.debug(f"Backup previous version copy: {filename}")
+            shutil.copy(self.filename, filename)
+            self._old_save_id += 1
+            is_new = True
+
+        if ".backup" in self.filename:
+            is_new = True
+
+        if not os.path.exists(self.filename):
+            is_new = True
+
+        self._init_db_file(self.filename, is_new=is_new)
+        self.commit()

        # Save
        self.last_save_date = datetime.now()
@@ -128,6 +143,16 @@ class Study(SQLModel):

    @filename.setter
    def filename(self, filename):
+        if filename is None:
+            self._filename = None
+            self.status.modified()
+            return
+
+        if self._filename is not None and self._filename != "":
+            self._filename = str(filename)
+            self.status.modified()
+            return
+
        self._filename = str(filename)
        self._init_db_file(filename, is_new=True)
        self.status.modified()
@@ -187,7 +212,12 @@ class Study(SQLModel):
    def _create(self):
        # Info (metadata)
        self.execute(
-            "CREATE TABLE info(key TEXT NOT NULL UNIQUE, value TEXT NOT NULL)")
+            "INSERT INTO info VALUES ('study_release', '0')"
+        )
+
+        self.execute(
+            "CREATE TABLE info(key TEXT NOT NULL UNIQUE, value TEXT NOT NULL)"
+        )
        self.execute(
            "INSERT INTO info VALUES ('version', " +
            f"'{self._db_format(self._version)}')",
@@ -196,19 +226,20 @@ class Study(SQLModel):
        self.execute("INSERT INTO info VALUES ('name', '')")
        self.execute("INSERT INTO info VALUES ('description', '')")
        self.execute(
-            f"INSERT INTO info VALUES ('time_system', '{self._time_system}')")
+            f"INSERT INTO info VALUES ('time_system', '{self._time_system}')"
+        )
        self.execute(
-            f"INSERT INTO info VALUES ('date', " +
-            "'{self._date.timestamp()}')"
+            "INSERT INTO info VALUES ('date', " +
+            f"'{timestamp(self._date)}')"
        )

        self.execute(
-            f"INSERT INTO info VALUES ('creation_date', " +
-            "'{self.creation_time.timestamp()}')"
+            "INSERT INTO info VALUES ('creation_date', " +
+            f"'{timestamp(self.creation_date)}')"
        )
        self.execute(
-            f"INSERT INTO info VALUES ('last_save_date', " +
-            "'{self.last_save_time.timestamp()}')"
+            "INSERT INTO info VALUES ('last_save_date', " +
+            f"'{timestamp(self.last_save_date)}')"
        )

        self._create_submodel()
@@ -221,7 +252,13 @@ class Study(SQLModel):
        if version[0] == self._version:
            return True

-        logger.info("Update database")
+        logger.debug("Update database")
+
+        major, minor, release = version[0].split('.')
+        if major == "0" and minor == "0" and int(release) < 10:
+            self.execute(
+                "INSERT INTO info VALUES ('study_release', '0')"
+            )

        if self._update_submodel(version[0]):
            self.execute(
@@ -236,6 +273,11 @@ class Study(SQLModel):
    def _load(cls, filename):
        new = cls(init_new=False, filename=filename)

+        version = new.execute(
+            "SELECT value FROM info WHERE key='study_release'"
+        )
+        new.status.version = int(version[0])
+
        # TODO: Load metadata
        new.name = new.execute("SELECT value FROM info WHERE key='name'")[0]
        new.description = new.execute(
@@ -270,6 +312,11 @@ class Study(SQLModel):
    def _save(self, progress=None):
        progress = progress if progress is not None else lambda: None

+        self.execute(
+            "INSERT INTO info VALUES ('study_release', " +
+            f"'{self.status.version}')"
+        )
+
        self.execute(
            f"UPDATE info SET " +
            f"value='{self._db_format(self.name)}' WHERE key='name'"
@@ -35,8 +35,10 @@ class SQLModel(SQL):
    _sub_classes = []

    def _init_db_file(self, db, is_new=True):
-        exists = Path(db).exists()
+        if self._db is not None:
+            self._db.close()

+        exists = Path(db).exists()
        if exists and is_new:
            os.remove(db)

@@ -68,6 +70,7 @@ class SQLModel(SQL):
        return True

    def _create(self):
+
        raise NotImplementedMethodeError(self, self._create)

    def _update_submodel(self, version):
@@ -56,7 +56,7 @@ class PamhyrModelDict(SQLSubModel):
    def __len__(self):
        return len(self._dict)

-    def is_defined(self, key):
+    def __contains__(self, key):
        return key in self._dict

    def set(self, key, new):
@@ -62,16 +62,27 @@ class PamhyrModelList(SQLSubModel):

    @property
    def lst(self):
+        """Return the PamhyrList as a Python list
+
+        Return the PamhyrList as a Python list.  This list is the
+        current list used in the PamhyrList object.  **If you need to
+        modify it, please make a copy.**
+
+        Returns: The Python list
+        """
        return self._lst

    def __len__(self):
        return len(self.lst)

-    def get(self, row):
-        return self._lst[row]
+    def index(self, el):
+        return self._lst.index(el)

-    def set(self, row, new):
-        self._lst[row] = new
+    def get(self, index):
+        return self._lst[index]
+
+    def set(self, index, new):
+        self._lst[index] = new
        if self._status is not None:
            self._status.modified()

@@ -93,6 +104,14 @@ class PamhyrModelList(SQLSubModel):
            self._status.modified()

    def delete(self, lst):
+        """Delete a list of elements
+
+        Args:
+            lst: The list of elements
+
+        Returns:
+            Nothing
+        """
        for el in lst:
            self._lst.remove(el)

@@ -100,6 +119,14 @@ class PamhyrModelList(SQLSubModel):
            self._status.modified()

    def delete_i(self, indexes):
+        """Delete elements from list of indexes
+
+        Args:
+            indexes: The elements indexes
+
+        Returns:
+            Nothing
+        """
        lst = list(
            map(
                lambda x: x[1],
@@ -175,16 +202,32 @@ class PamhyrModelListWithTab(SQLSubModel):
    ################

    def len(self, lst):
+        """Size of tab list
+
+        Args:
+            lst: The tab name
+
+        Returns:
+            The size of the tab list
+        """
        return len(self._tabs[lst])

    def get_tab(self, lst):
+        """Get tab list (copy) from name
+
+        Args:
+            lst: The tab name
+
+        Returns:
+            Nothing
+        """
        return self._tabs[lst].copy()

-    def get(self, lst, row):
-        return self._tabs[lst][row]
+    def get(self, lst, index):
+        return self._tabs[lst][index]

-    def set(self, lst, row, new):
-        self._tabs[lst][row] = new
+    def set(self, lst, index, new):
+        self._tabs[lst][index] = new
        self._status.modified()

    def new(self, lst, index):
@@ -200,15 +243,43 @@ class PamhyrModelListWithTab(SQLSubModel):
        raise NotImplementedMethodeError(self, self.new)

    def insert(self, lst, index, new):
+        """Insert element in tab
+
+        Args:
+            lst: The tab name
+            index: The index of new element
+            new: The new elements
+
+        Returns:
+            Nothing
+        """
        self._tabs[lst].insert(index, new)
        self._status.modified()

    def delete(self, lst, els):
+        """Delete elements from specific tab
+
+        Args:
+            lst: The tab name
+            els: The elements list
+
+        Returns:
+            Nothing
+        """
        for el in els:
            self._tabs[lst].remove(el)
        self._status.modified()

    def delete_i(self, lst, indexes):
+        """Delete elements from specific tab
+
+        Args:
+            lst: The tab name
+            indexes: The elements indexes
+
+        Returns:
+            Nothing
+        """
        els = list(
            map(
                lambda x: x[1],
@@ -0,0 +1,164 @@
+# Modules.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 logging
+
+from enum import Flag, auto
+
+logger = logging.getLogger()
+
+
+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
+    STUDY = auto()
+    CONFIG = auto()
+
+    # Modelling
+    NETWORK = auto()
+    GEOMETRY = auto()
+    BOUNDARY_CONDITION = auto()
+    LATERAL_CONTRIBUTION = auto()
+    FRICTION = auto()
+    INITIAL_CONDITION = auto()
+    HYDRAULIC_STRUCTURES = auto()
+    RESERVOIR = auto()
+    SEDIMENT_LAYER = auto()
+    ADDITIONAL_FILES = auto()
+
+    # Results
+    RESULTS = auto()
+
+    # 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,
+        ]
+
+    @classmethod
+    def all(cls):
+        return ~cls.NONE
+
+    @classmethod
+    def modelling(cls):
+        return (
+            cls.NETWORK
+            | cls.GEOMETRY
+            | cls.BOUNDARY_CONDITION
+            | cls.LATERAL_CONTRIBUTION
+            | cls.FRICTION
+            | cls.INITIAL_CONDITION
+            | cls.HYDRAULIC_STRUCTURES
+            | cls.RESERVOIR
+            | cls.SEDIMENT_LAYER
+        )
+
+    @classmethod
+    def modelling_list(cls):
+        return [
+            cls.NETWORK,
+            cls.GEOMETRY,
+            cls.BOUNDARY_CONDITION,
+            cls.LATERAL_CONTRIBUTION,
+            cls.FRICTION,
+            cls.INITIAL_CONDITION,
+            cls.HYDRAULIC_STRUCTURES,
+            cls.RESERVOIR,
+            cls.SEDIMENT_LAYER,
+        ]
+
+    @classmethod
+    def modelling_display_name(cls):
+        return {
+            cls.NETWORK: "Network",
+            cls.GEOMETRY: "Geometry",
+            cls.BOUNDARY_CONDITION: "Boundary condition",
+            cls.LATERAL_CONTRIBUTION: "Lateral contribution",
+            cls.FRICTION: "Friction",
+            cls.INITIAL_CONDITION: "Initial condition",
+            cls.HYDRAULIC_STRUCTURES: "Hydraulic structures",
+            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: [],
+}
@@ -19,7 +19,8 @@
 import os
 import logging

-from tools import timer, parse_command_line
+from datetime import datetime
+from tools import timer, parse_command_line, get_version, logger_exception

 try:
    # Installation allow Unix-like signal
@@ -124,6 +125,54 @@ class CommandLineSolver(AbstractSolver):
        """
        raise NotImplementedMethodeError(self, self.log_file)

+    def export_additional_files(self, study, repertory, qlog, name="0"):
+        files = []
+
+        if qlog is not None:
+            qlog.put("Export additional files")
+
+        add_files = study.river.additional_files.files
+        for add_file in add_files:
+            self.export_additional_file(
+                study, add_file, repertory, files
+            )
+
+        return files
+
+    def export_additional_file(self, study, add_file, repertory, files):
+        if add_file.path == "" or not add_file.is_enabled():
+            return files
+
+        path = os.path.join(repertory, add_file.path)
+        os.makedirs(
+            os.path.dirname(path),
+            exist_ok=True
+        )
+
+        with open(path, "w+") as f:
+            files.append(add_file.path)
+
+            txt = add_file.text
+            txt = txt.replace("@version", get_version())
+            txt = txt.replace("@date", datetime.now().isoformat(sep=" "))
+
+            f.write(txt)
+
+        return files
+
+    def export_study_description(self, study, repertory, qlog, name="0"):
+        files = []
+
+        path = os.path.join(
+            repertory, "pamhyr-study-description.txt"
+        )
+
+        with open(path, "w+", encoding='utf-8') as f:
+            txt = study.description\
+                       .encode()\
+                       .decode('utf-8', 'replace')
+            f.write(txt)
+
    #######
    # Run #
    #######
@@ -132,7 +181,7 @@ class CommandLineSolver(AbstractSolver):
        return os.path.abspath(
            os.path.join(
                os.path.dirname(__file__),
-                "..", "..", ".."
+                "..", ".."
            )
        )

@@ -224,12 +273,15 @@ class CommandLineSolver(AbstractSolver):
        return True

    def _data_ready(self):
-        # Read process output and put lines in queue
-        s = self._process.readAll().data().decode()
+        try:
+            # Read process output and put lines in queue
+            s = self._process.readAll().data().decode('utf-8', "replace")

-        if self._output is not None:
-            for x in s.split('\n'):
-                self._output.put(x)
+            if self._output is not None:
+                for x in s.split(os.linesep):
+                    self._output.put(x)
+        except Exception as e:
+            logger_exception(e)

    def _finished(self, study, exit_code, exit_status):
        if self._output is not None:
@@ -20,7 +20,7 @@ import os
 import logging
 import numpy as np

-from tools import timer, trace
+from tools import timer, trace, logger_exception

 from Solver.CommandLine import CommandLineSolver
 from Checker.Mage import (
@@ -98,10 +98,9 @@ class Mage(CommandLineSolver):
    @classmethod
    def checkers(cls):
        lst = [
-            MageNetworkGraphChecker(connectivity=True),
-            MageNetworkGraphChecker(connectivity=False),
-            MageGeometryGuideLineChecker(),
-
+            MageNetworkGraphChecker(connectivity=True, version=cls._type),
+            MageNetworkGraphChecker(connectivity=False, version=cls._type),
+            MageGeometryGuideLineChecker(version=cls._type),
        ]

        return lst
@@ -129,7 +128,15 @@ class Mage(CommandLineSolver):
        name = self._study.name
        return f"{name}.TRA"

-    @timer
+    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_ST(self, study, repertory, qlog, name="0"):
        files = []

@@ -139,14 +146,7 @@ class Mage(CommandLineSolver):
        os.makedirs(os.path.join(repertory, "net"), exist_ok=True)

        # Write header
-        edges = study.river.edges()
-        edges = list(
-            filter(
-                lambda e: e.is_enable(),
-                edges
-            )
-        )
-
+        edges = study.river.enable_edges()
        for edge in edges:
            name = f"Reach_{edge.id + 1:>3}".replace(" ", "0")

@@ -180,7 +180,7 @@ class Mage(CommandLineSolver):
        c1 = f"{profile.code1:>6}"
        c2 = f"{profile.code2:>6}"
        t = f"{len(profile.points):>6}"
-        kp = f"{profile.kp:>12f}"[0:12]
+        rk = f"{profile.rk:>12f}"[0:12]
        pname = profile.name
        if profile.name == "":
            # Generate name from profile id prefixed with
@@ -207,7 +207,7 @@ class Mage(CommandLineSolver):
                )

        # Profile header line
-        wfile.write(f"{num}{c1}{c2}{t} {kp} {pname} {sediment}\n")
+        wfile.write(f"{num}{c1}{c2}{t} {rk} {pname} {sediment}\n")

    def _export_ST_point_line(self, wfile, files, point):
        x = f"{point.x:<12.4f}"[0:12]
@@ -235,7 +235,6 @@ class Mage(CommandLineSolver):
        # Point line
        wfile.write(f"{x} {y} {z} {n} {sediment}\n")

-    @timer
    def _export_BC(self, t, bounds, repertory, qlog, name="0"):
        files = []

@@ -269,7 +268,6 @@ class Mage(CommandLineSolver):

        return files

-    @timer
    def _export_bound_cond(self, study, repertory, qlog, name="0"):
        files = []
        lst = study.river.boundary_condition
@@ -284,6 +282,9 @@ class Mage(CommandLineSolver):
                if bound.node is None:
                    continue

+                if not study.river.is_enable_node(bound.node):
+                    continue
+
                if bound.bctype == "ZD":
                    AVA.append(bound)
                elif bound.bctype == "TD" or bound.bctype == "PC":
@@ -300,42 +301,55 @@ class Mage(CommandLineSolver):

        return files

-    # @timer
-    # def _export_LC(self, lateral, repertory, qlog, name="0"):
-    #     files = []
+    def _export_lateral_contrib(self, study, repertory, qlog, name="0"):
+        files = []
+        lst = study.river.lateral_contribution

-    #     if qlog is not None:
-    #         qlog.put(f"Export LAT file")
+        with mage_file_open(
+                os.path.join(repertory, f"{name}.LAT"),
+                "w+"
+        ) as f:
+            if qlog is not None:
+                qlog.put(f"Export LAT file")
+            files.append(f"{name}.LAT")

-    #     with mage_file_open(
-    #             os.path.join(repertory, f"{name}.LAT"),
-    #             "w+"
-    #     ) as f:
-    #         files.append(f"{name}.LAT")
+            for tab in ["liquid", "solid", "suspenssion"]:
+                for lateral in lst.get_tab(tab):
+                    self._export_LC(study, lateral, f,  qlog)

-    #         name = f"{lateral.node.id:3}".replace(" ", "x")
-    #         f.write(f"* {lateral.node.name} ({name}) {lateral.bctype}\n")
-    #         f.write(f"${name}\n")
-    #         header = lateral.header
-    #         f.write(f"*{header[0]:>9}|{header[1]:>10}\n")
+        return files

-    #         for d in lateral.data:
-    #             f.write(f"{d[0]:1{name}.3f}{d[1]:10.3f}\n")
+    def _export_LC(self, study, lateral, f, qlog, name="0"):
+        if lateral.edge is None:
+            return

-    #     return files
+        edges = study.river.enable_edges()
+        if lateral.edge not in edges:
+            return

-    # @timer
-    # def _export_lateral_contrib(self, study, repertory, qlog, name="0"):
-    #     files = []
-    #     lst = study.river.lateral_contribution
+        eid, _ = next(
+            filter(
+                lambda e: e[1] == lateral.edge,
+                enumerate(edges)
+            )
+        )

-    #     for tab in ["liquid", "solid", "suspenssion"]:
-    #         for lateral in lst.get_tab(tab):
-    #             files = files + self._export_LC(lateral, repertory,  qlog)
+        name = f"{eid+1:>3}"
+        # name = f"Reach_{lateral.edge.id + 1:>3}".replace(" ", "0")
+        f.write(f"* {lateral.edge.name} ({name}) {lateral.lctype}\n")
+        f.write(
+            f"${name}    " +
+            f"{lateral.begin_rk:>10.4f} {lateral.end_rk:>10.4f}\n"
+        )
+        header = lateral.header
+        f.write(f"*{header[0]:>9}|{header[1]:>10}\n")

-    #     return files
+        for d in lateral.data:
+            if lateral.lctype in ["EV"]:
+                f.write(f"{d[0]:10.3f}{-d[1]:10.3f}\n")
+            else:
+                f.write(f"{d[0]:10.3f}{d[1]:10.3f}\n")

-    @timer
    def _export_RUG(self, study, repertory, qlog, name="0"):
        files = []

@@ -346,13 +360,7 @@ class Mage(CommandLineSolver):
        with mage_file_open(os.path.join(repertory, f"{name}.RUG"), "w+") as f:
            files.append(f"{name}.RUG")

-            edges = study.river.edges()
-            edges = list(
-                filter(
-                    lambda e: e.is_enable(),
-                    edges
-                )
-            )
+            edges = study.river.enable_edges()

            id = 1
            for edge in edges:
@@ -363,23 +371,22 @@ class Mage(CommandLineSolver):
                        continue

                    num = f"{id:>3}"
-                    bkp = f"{friction.begin_kp:>10.3f}"
-                    ekp = f"{friction.end_kp:>10.3f}"
+                    brk = f"{friction.begin_rk:>10.3f}"
+                    erk = f"{friction.end_rk:>10.3f}"

-                    # if friction.begin_kp != friction.end_kp:
+                    # if friction.begin_rk != friction.end_rk:
                    #     print("TODO")

                    strickler = friction.begin_strickler
                    coef_1 = f"{strickler.minor:>10.3f}"
                    coef_2 = f"{strickler.medium:>10.3f}"

-                    f.write(f"K{num}      {bkp}{ekp}{coef_1}{coef_2}\n")
+                    f.write(f"K{num}      {brk}{erk}{coef_1}{coef_2}\n")

                id += 1

        return files

-    @timer
    def _export_INI(self, study, repertory, qlog, name="0"):
        files = []

@@ -394,7 +401,7 @@ class Mage(CommandLineSolver):

            # TODO put real date...
            f.write(f"$ date en minutes :       0.00\n")
-            f.write(f"* IB IS    discharge  elevation         kp\n")
+            f.write(f"* IB IS    discharge  elevation         rk\n")

            id = 1
            for reach in reachs:
@@ -411,9 +418,9 @@ class Mage(CommandLineSolver):
                    IS = f"{id_sec}"
                    discharge = f"{d['discharge']:>10.5f}"
                    elevation = f"{d['elevation']:>11.6f}"
-                    kp = f"{d['kp']:>9.2f}"
+                    rk = f"{d['rk']:>9.2f}"

-                    f.write(f"{IR} {IS} {discharge} {elevation} {kp}\n")
+                    f.write(f"{IR} {IS} {discharge} {elevation} {rk}\n")
                    id_sec += 1

                id += 1
@@ -422,7 +429,6 @@ class Mage(CommandLineSolver):
            files.append(f"{name}.INI")
        return files

-    @timer
    def _export_CAS(self, study, repertory, qlog, name="0"):
        files = []

@@ -455,7 +461,6 @@ class Mage(CommandLineSolver):

        return files

-    @timer
    def _export_SIN(self, study, repertory, qlog, name="0"):
        files = []

@@ -487,35 +492,45 @@ class Mage(CommandLineSolver):
                if not hs.input_reach.is_enable():
                    continue

+                if not hs.enabled:
+                    continue
+
+                if hs.input_rk is None:
+                    continue
+
                f.write(
                    '* ouvrage au pk ' +
-                    f"{float(hs.input_kp):>12.1f}" + ' ' +
+                    f"{float(hs.input_rk):>12.1f}" + ' ' +
                    hs.name + '\n'
                )

-                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)
-                        ]
-                    )
-
-                    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"
-                    )
+                self._export_SIN_bhs(study, sin_dict, hs, f)

        return files

+    def _export_SIN_bhs(self, study, sin_dict, hs, f):
+        for bhs in hs.basic_structures:
+            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(" ", "_")
+
+                f.write(
+                    f"{sin_dict[bhs._type]} " +
+                    f"{reach_id} {float(hs.input_rk):>12.3f} " +
+                    f"{param_str} {name}\n"
+                )
+
    def _export_SIN_parameters(self, bhs):
        res = [9999.999] * 5

@@ -574,7 +589,6 @@ class Mage(CommandLineSolver):

        return res

-    @timer
    def _export_VAR(self, study, repertory, qlog, name="0"):
        files = []

@@ -610,7 +624,6 @@ class Mage(CommandLineSolver):

        return files

-    @timer
    def _export_DEV(self, study, repertory, qlog, name="0"):
        files = []

@@ -633,7 +646,6 @@ class Mage(CommandLineSolver):

        return files

-    @timer
    def _export_REP(self, study, repertory, files, qlog, name="0"):
        if qlog is not None:
            qlog.put("Export REP file")
@@ -655,6 +667,7 @@ class Mage(CommandLineSolver):
            f.write("* OUTPUT\n")
            f.write(f"TRA {name}.TRA\n")
            f.write(f"BIN {name}.BIN\n")
+            f.write(f"ERR {name}.ERR\n")

            for file in files:
                EXT = file.split('.')[1]
@@ -662,6 +675,8 @@ class Mage(CommandLineSolver):
                if EXT in ["GRA"]:
                    f.write(f"{EXT} {file}\n")

+            self._export_REP_additional_lines(study, f)
+
    @timer
    def export(self, study, repertory, qlog=None):
        self._study = study
@@ -672,6 +687,8 @@ class Mage(CommandLineSolver):
        self._bin_file = f"{name}.BIN"

        self._export_ST(study, repertory, qlog, name=name)
+        self.export_additional_files(study, repertory, qlog, name=name)
+        self.export_study_description(study, repertory, qlog, name=name)

        return True

@@ -763,7 +780,6 @@ class Mage8(Mage):

        return lst

-    @timer
    def _export_PAR(self, study, repertory, qlog=None, name="0"):
        files = []

@@ -787,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(
@@ -798,7 +814,6 @@ class Mage8(Mage):

        return files

-    @timer
    def _export_NET(self, study, repertory, qlog=None, name="0"):
        files = []

@@ -808,13 +823,7 @@ class Mage8(Mage):
        with mage_file_open(os.path.join(repertory, f"{name}.NET"), "w+") as f:
            files.append(f"{name}.NET")

-            edges = study.river.edges()
-            edges = list(
-                filter(
-                    lambda e: e.is_enable(),
-                    edges
-                )
-            )
+            edges = study.river.enable_edges()

            for e in edges:
                name = f"Reach_{e.id + 1:>3}".replace(" ", "0")
@@ -828,7 +837,6 @@ class Mage8(Mage):

        return files

-    @timer
    def _export_QSO(self, bounds, repertory, qlog, name="0"):
        files = []

@@ -864,6 +872,16 @@ class Mage8(Mage):

        return files

+    def export_func_dict(self):
+        return [
+            self._export_ST, self._export_PAR,
+            self._export_NET, self._export_bound_cond,
+            self._export_RUG, self._export_INI,
+            self._export_SIN, self._export_VAR,
+            self._export_CAS, self._export_DEV,
+            self._export_lateral_contrib,
+        ]
+
    @timer
    def export(self, study, repertory, qlog=None, name="0"):
        self._study = study
@@ -876,20 +894,19 @@ class Mage8(Mage):
        # Generate files
        files = []

-        files = self._export_ST(study, repertory, qlog, name=name)
-        files = files + self._export_PAR(study, repertory, qlog, name=name)
-        files = files + self._export_NET(study, repertory, qlog, name=name)
-        files = files + \
-            self._export_bound_cond(study, repertory, qlog, name=name)
-        files = files + self._export_RUG(study, repertory, qlog, name=name)
-        files = files + self._export_INI(study, repertory, qlog, name=name)
-        files = files + self._export_SIN(study, repertory, qlog, name=name)
-        files = files + self._export_VAR(study, repertory, qlog, name=name)
-        files = files + self._export_CAS(study, repertory, qlog, name=name)
-        files = files + self._export_DEV(study, repertory, qlog, name=name)
-        self._export_REP(study, repertory, files, qlog, name=name)
+        try:
+            for func in self.export_func_dict():
+                files = files + func(study, repertory, qlog, name=name)

-        return True
+            self.export_additional_files(study, repertory, qlog, name=name)
+            self.export_study_description(study, repertory, qlog, name=name)
+            self._export_REP(study, repertory, 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

    ###########
    # RESULTS #
@@ -1202,12 +1219,34 @@ class Mage8(Mage):
            logger.info(f"read_gra: ... end with {len(ts)} timestamp read")

    @timer
-    def results(self, study, repertory, qlog=None, name=None):
+    def results(self, study, repertory,
+                qlog=None, name=None,
+                with_gra=True):
        self._study = study
        if name is None:
            name = study.name.replace(" ", "_")

        results = super(Mage8, self).results(study, repertory, qlog, name=name)
-        self.read_gra(study, repertory, results, qlog, name=name)
+        if with_gra:
+            self.read_gra(study, repertory, results, qlog, name=name)

        return results
+
+
+class MageFake7(Mage8):
+    _type = "mage_fake7"
+
+    def __init__(self, name):
+        super(MageFake7, self).__init__(name)
+
+        self._type = "mage_fake7"
+
+    @timer
+    def results(self, study, repertory,
+                qlog=None, name=None,
+                with_gra=False):
+        results = super(MageFake7, self).results(
+            study, repertory,
+            qlog, name=name, with_gra=with_gra
+        )
+        return results
@@ -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:
+                    rk = profile.rk
+                    n_points = len(profile)
+
+                    f.write(f"{ind:>4} {rk:>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_rk(),
+                              reach.get_rk()]:
+                    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_rk(rk):
+                    return next(
+                        map(
+                            lambda s: (
+                                s.begin_strickler.medium if version == "2"
+                                else s.begin_strickler.minor
+                            ),
+                            filter(
+                                lambda f: rk in f,
+                                edge.frictions.lst
+                            )
+                        )
+                    )
+
+                ind = 1
+                for mail in edge.reach.inter_profiles_rk():
+                    coef = get_stricklers_from_rk(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.rk not in data or last.rk 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.rk 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['rk']] = (
+                d['elevation'],
+                d['discharge'],
+            )
+
+        return data
+
+    def _export_tps_profile_height_speed(self, profile, data):
+        z = data[profile.rk][0]
+        q = data[profile.rk][1]
+
+        height = z - profile.z_min()
+        speed = profile.speed(q, z)
+
+        return height, speed
@@ -19,7 +19,10 @@
 from PyQt5.QtCore import QCoreApplication

 from Solver.GenericSolver import GenericSolver
-from Solver.Mage import Mage7, Mage8
+from Solver.Mage import (
+    Mage7, Mage8, MageFake7,
+)
+from Solver.RubarBE import RubarBE

 _translate = QCoreApplication.translate

@@ -27,10 +30,14 @@ solver_long_name = {
    # "generic": "Generic",
    # "mage7": "Mage v7",
    "mage8": "Mage v8",
+    # "mage_fake7": "Mage fake v7",
+    # "rubarbe": "RubarBE",
 }

 solver_type_list = {
    # "generic": GenericSolver,
    # "mage7": Mage7,
    "mage8": Mage8,
+    # "mage_fake7": MageFake7,
+    # "rubarbe": RubarBE,
 }
@@ -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)
@@ -0,0 +1,90 @@
+# Window.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 logging
+
+from Modules import Modules
+from View.Tools.PamhyrWindow import PamhyrWindow
+
+from PyQt5.QtWidgets import (
+    QLabel, QPlainTextEdit, QPushButton,
+    QCheckBox,
+)
+
+from View.AdditionalFiles.Translate import AddFileTranslate
+from View.AdditionalFiles.UndoCommand import (
+    SetCommand
+)
+
+logger = logging.getLogger()
+
+
+class EditAddFileWindow(PamhyrWindow):
+    _pamhyr_ui = "AdditionalFile"
+    _pamhyr_name = "Edit additional file"
+
+    def __init__(self, study=None, config=None, add_file=None,
+                 trad=None, undo=None, parent=None):
+
+        name = trad[self._pamhyr_name] + " - " + study.name
+        super(EditAddFileWindow, self).__init__(
+            title=name,
+            study=study,
+            config=config,
+            options=[],
+            parent=parent
+        )
+
+        self._add_file = add_file
+        self._hash_data.append(self._add_file)
+
+        self._undo = undo
+
+        self.setup_values()
+        self.setup_connection()
+
+    def setup_values(self):
+        self.set_check_box("checkBox", self._add_file.enabled)
+        self.set_line_edit_text("lineEdit_name", self._add_file.name)
+        self.set_line_edit_text("lineEdit_path", self._add_file.path)
+        self.set_plaintext_edit_text("plainTextEdit", self._add_file.text)
+
+    def setup_connection(self):
+        self.find(QPushButton, "pushButton_cancel")\
+            .clicked.connect(self.close)
+        self.find(QPushButton, "pushButton_ok")\
+            .clicked.connect(self.accept)
+
+    def accept(self):
+        is_enabled = self.get_check_box("checkBox")
+        name = self.get_line_edit_text("lineEdit_name")
+        path = self.get_line_edit_text("lineEdit_path")
+        text = self.get_plaintext_edit_text("plainTextEdit")
+
+        self._undo.push(
+            SetCommand(
+                self._add_file,
+                enabled=is_enabled,
+                name=name,
+                path=path,
+                text=text,
+            )
+        )
+
+        self._propagate_update(key=Modules.ADDITIONAL_FILES)
+        self.close()
@@ -0,0 +1,81 @@
+# List.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 logging
+
+from functools import reduce
+from tools import trace, timer
+
+from PyQt5.QtCore import (
+    Qt, QVariant,
+)
+
+from PyQt5.QtGui import (
+    QColor, QBrush,
+)
+
+from View.Tools.PamhyrList import PamhyrListModel
+from View.AdditionalFiles.UndoCommand import (
+    AddCommand, DelCommand
+)
+
+logger = logging.getLogger()
+
+
+class ListModel(PamhyrListModel):
+    def data(self, index, role):
+        row = index.row()
+        column = index.column()
+
+        file = self._data.files[row]
+
+        if role == Qt.ForegroundRole:
+            color = Qt.gray
+
+            if file.is_enabled():
+                color = QColor("black")
+            else:
+                color = QColor("grey")
+
+            return QBrush(color)
+
+        if role == Qt.ItemDataRole.DisplayRole:
+            text = f"{file.name}: '{file.path}'"
+
+            if not file.is_enabled():
+                text += " (disabled)"
+
+            return text
+
+        return QVariant()
+
+    def add(self, row):
+        self._undo.push(
+            AddCommand(
+                self._data, row
+            )
+        )
+        self.update()
+
+    def delete(self, row):
+        self._undo.push(
+            DelCommand(
+                self._data, row
+            )
+        )
+        self.update()
@@ -0,0 +1,35 @@
+# Translate.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 PyQt5.QtCore import QCoreApplication
+from View.Translate import MainTranslate
+
+_translate = QCoreApplication.translate
+
+
+class AddFileTranslate(MainTranslate):
+    def __init__(self):
+        super(AddFileTranslate, self).__init__()
+
+        self._dict["Additional files"] = _translate(
+            "AdditionalFiles", "Additional files"
+        )
+
+        self._dict["Edit additional file"] = _translate(
+            "AdditionalFiles", "Edit additional file"
+        )
@@ -0,0 +1,82 @@
+# UndoCommand.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 PyQt5.QtWidgets import (
+    QMessageBox, QUndoCommand, QUndoStack,
+)
+
+
+class SetCommand(QUndoCommand):
+    def __init__(self, add_file, **kwargs):
+        QUndoCommand.__init__(self)
+
+        self._add_file = add_file
+        self._new = kwargs
+        self._old = None
+
+    def undo(self):
+        f = self._add_file
+
+        for key in self._old:
+            f[key] = self._old[key]
+
+    def redo(self):
+        f = self._add_file
+
+        if self._old is None:
+            self._old = {}
+            for key in self._new:
+                self._old[key] = f[key]
+
+        for key in self._new:
+            f[key] = self._new[key]
+
+
+class AddCommand(QUndoCommand):
+    def __init__(self, files, row):
+        QUndoCommand.__init__(self)
+
+        self._files = files
+        self._row = row
+        self._new = None
+
+    def undo(self):
+        self._files.delete([self._new])
+
+    def redo(self):
+        if self._new is None:
+            self._new = self._files.new(self._row)
+        else:
+            self._files.insert(self._row, self._new)
+
+
+class DelCommand(QUndoCommand):
+    def __init__(self, files, row):
+        QUndoCommand.__init__(self)
+
+        self._files = files
+        self._row = row
+        self._old = self._files.get(row)
+
+    def undo(self):
+        self._files.insert(self._row, self._old)
+
+    def redo(self):
+        self._files.delete_i([self._row])
@@ -0,0 +1,118 @@
+# Window.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 PyQt5.QtWidgets import (
+    QAction, QListView,
+)
+
+from View.Tools.PamhyrWindow import PamhyrWindow
+
+from View.AdditionalFiles.List import ListModel
+from View.AdditionalFiles.Translate import AddFileTranslate
+from View.AdditionalFiles.Edit.Window import EditAddFileWindow
+
+
+class AddFileListWindow(PamhyrWindow):
+    _pamhyr_ui = "AdditionalFileList"
+    _pamhyr_name = "Additional files"
+
+    def __init__(self, study=None, config=None,
+                 parent=None):
+        trad = AddFileTranslate()
+        name = trad[self._pamhyr_name] + " - " + study.name
+
+        super(AddFileListWindow, self).__init__(
+            title=name,
+            study=study,
+            config=config,
+            trad=trad,
+            options=[],
+            parent=parent
+        )
+
+        self.setup_list()
+        self.setup_connections()
+
+    def setup_list(self):
+        lst = self.find(QListView, f"listView")
+        self._list = ListModel(
+            list_view=lst,
+            data=self._study.river.additional_files,
+            undo=self._undo_stack,
+            trad=self._trad,
+        )
+
+    def setup_connections(self):
+        self.find(QAction, "action_add").triggered.connect(self.add)
+        self.find(QAction, "action_delete").triggered.connect(self.delete)
+        self.find(QAction, "action_edit").triggered.connect(self.edit)
+
+    def update(self):
+        self._list.update()
+
+    def selected_rows(self):
+        lst = self.find(QListView, f"listView")
+        return list(map(lambda i: i.row(), lst.selectedIndexes()))
+
+    def add(self):
+        rows = self.selected_rows()
+        if len(rows) > 0:
+            row = rows[0]
+        else:
+            row = 0
+
+        self._list.add(row)
+
+    def delete(self):
+        rows = self.selected_rows()
+        if len(rows) == 0:
+            return
+
+        self._list.delete(rows[0])
+
+    def edit(self):
+        rows = self.selected_rows()
+
+        for row in rows:
+            add_file = self._study.river.additional_files.files[row]
+
+            if self.sub_window_exists(
+                    EditAddFileWindow,
+                    data=[self._study, self._config, add_file]
+            ):
+                continue
+
+            win = EditAddFileWindow(
+                study=self._study,
+                config=self._config,
+                add_file=add_file,
+                trad=self._trad,
+                undo=self._undo_stack,
+                parent=self,
+            )
+            win.show()
+
+    def _undo(self):
+        self._undo_stack.undo()
+        self.update()
+
+    def _redo(self):
+        self._undo_stack.redo()
+        self.update()
@@ -99,7 +99,7 @@ class TableModel(PamhyrTableModel):
            logger.info(e)
            logger.debug(traceback.format_exc())

-        self.dataChanged.emit(index, index)
+        self.update()
        return True

    def add(self, row, parent=QModelIndex()):
@@ -112,7 +112,7 @@ class TableModel(PamhyrTableModel):
        )

        self.endInsertRows()
-        self.layoutChanged.emit()
+        self.update()

    def delete(self, rows, parent=QModelIndex()):
        self.beginRemoveRows(parent, rows[0], rows[-1])
@@ -135,7 +135,7 @@ class TableModel(PamhyrTableModel):
        )

        self.layoutAboutToBeChanged.emit()
-        self.layoutChanged.emit()
+        self.update()

    def move_up(self, row, parent=QModelIndex()):
        if row <= 0:
@@ -152,7 +152,7 @@ class TableModel(PamhyrTableModel):
        )

        self.endMoveRows()
-        self.layoutChanged.emit()
+        self.update()

    def move_down(self, index, parent=QModelIndex()):
        if row > len(self._data):
@@ -169,7 +169,7 @@ class TableModel(PamhyrTableModel):
        )

        self.endMoveRows()
-        self.layoutChanged.emit()
+        self.update()

    def paste(self, row, header, data):
        if len(data) == 0:
@@ -190,4 +190,13 @@ class TableModel(PamhyrTableModel):
        )

        self.layoutAboutToBeChanged.emit()
+        self.update()
+
+    def auto_sort(self):
+        self.layoutAboutToBeChanged.emit()
+        self._data.sort(key=lambda x: x[0])
+        self.layoutAboutToBeChanged.emit()
+
+    def update(self):
+        # self.auto_sort()
        self.layoutChanged.emit()
@@ -108,7 +108,7 @@ class EditBoundaryConditionWindow(PamhyrWindow):
        name = trad[self._pamhyr_name]
        if self._data is not None:
            node_name = (self._data.node.name if self._data.node is not None
-                         else _translate("BoundaryCondition", "Not associate"))
+                         else trad['not_associated'])
            name += (
                f" - {study.name} " +
                f" - {self._data.name} ({self._data.id}) " +
@@ -195,6 +195,7 @@ class EditBoundaryConditionWindow(PamhyrWindow):
        self.find(QAction, "action_sort").triggered.connect(self.sort)

        self._table.dataChanged.connect(self.update)
+        self._table.layoutChanged.connect(self.update)

        if self._is_solid:
            self._d50sigma.d50Changed.connect(self.d50_changed)
@@ -18,7 +18,7 @@

 from PyQt5.QtCore import QCoreApplication

-from View.Tools.PamhyrTranslate import PamhyrTranslate
+from View.Translate import MainTranslate

 from View.BoundaryCondition.translate import BCTranslate

@@ -36,9 +36,9 @@ class BCETranslate(BCTranslate):
        self._sub_dict["table_headers"] = {
            "x": _translate("BoundaryCondition", "X"),
            "y": _translate("BoundaryCondition", "Y"),
-            "time": _translate("BoundaryCondition", "Time"),
-            "date": _translate("BoundaryCondition", "Date"),
-            "discharge": _translate("BoundaryCondition", "Discharge (m³/s)"),
-            "z": _translate("BoundaryCondition", "Z (m)"),
+            "time": self._dict["time"],
+            "date": self._dict["date"],
+            "discharge": self._dict["unit_discharge"],
+            "z": self._dict["unit_elevation"],
            "solid": _translate("BoundaryCondition", "Solid (kg/s)"),
        }
@@ -85,7 +85,7 @@ class ComboBoxDelegate(QItemDelegate):
            )
        else:
            self.editor.addItems(
-                [_translate("BoundaryCondition", "Not associate")] +
+                [self._trad["not_associated"]] +
                self._data.nodes_names()
            )

@@ -145,7 +145,7 @@ class TableModel(PamhyrTableModel):
        elif self._headers[column] == "node":
            n = self._lst.get(self._tab, row).node
            if n is None:
-                return _translate("BoundaryCondition", "Not associate")
+                return self._trad["not_associated"]
            return n.name

        return QVariant()
@@ -18,7 +18,7 @@

 import logging

-from tools import trace, timer
+from tools import trace, timer, logger_exception

 from View.Tools.PamhyrWindow import PamhyrWindow

@@ -37,6 +37,7 @@ from PyQt5.QtWidgets import (
    QFileDialog, QTableView, QAbstractItemView,
    QUndoStack, QShortcut, QAction, QItemDelegate,
    QComboBox, QVBoxLayout, QHeaderView, QTabWidget,
+    QWidget,
 )

 from Model.BoundaryCondition.BoundaryConditionTypes import (
@@ -170,6 +171,13 @@ class BoundaryConditionWindow(PamhyrWindow):
            )
        )

+    def set_active_tab(self, tab_id=0):
+        try:
+            tab_widget = self.find(QTabWidget, "tabWidget")
+            tab_widget.setCurrentIndex(tab_id)
+        except Exception as e:
+            logger_exception(e)
+
    def add(self):
        tab = self.current_tab()
        rows = self.index_selected_rows()
@@ -18,7 +18,7 @@

 from PyQt5.QtCore import QCoreApplication

-from View.Tools.PamhyrTranslate import PamhyrTranslate
+from View.Translate import MainTranslate

 from Model.BoundaryCondition.BoundaryConditionTypes import (
    NotDefined, PonctualContribution,
@@ -38,7 +38,7 @@ BC_types = {
 }


-class BCTranslate(PamhyrTranslate):
+class BCTranslate(MainTranslate):
    def __init__(self):
        super(BCTranslate, self).__init__()

@@ -47,8 +47,8 @@ class BCTranslate(PamhyrTranslate):
        )

        self._sub_dict["long_types"] = {
-            "ND": _translate("BoundaryCondition", "Not defined"),
-            "PC": _translate("BoundaryCondition", "Ponctual contribution"),
+            "ND": self._dict["not_defined"],
+            "PC": _translate("BoundaryCondition", "Point sources"),
            "TZ": _translate("BoundaryCondition", "Z(t)"),
            "TD": _translate("BoundaryCondition", "Q(t)"),
            "ZD": _translate("BoundaryCondition", "Q(Z)"),
@@ -56,7 +56,7 @@ class BCTranslate(PamhyrTranslate):
        }

        self._sub_dict["table_headers"] = {
-            "name": _translate("BoundaryCondition", "Name"),
-            "type": _translate("BoundaryCondition", "Type"),
+            "name": self._dict["name"],
+            "type": self._dict["type"],
            "node": _translate("BoundaryCondition", "Node")
        }
@@ -0,0 +1,67 @@
+# List.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 logging
+
+from functools import reduce
+from tools import trace, timer
+
+from PyQt5.QtCore import (
+    Qt, QVariant,
+)
+
+from PyQt5.QtGui import (
+    QColor, QBrush,
+)
+
+from Modules import Modules
+from Checker.Checker import STATUS
+from View.Tools.PamhyrList import PamhyrListModel
+
+logger = logging.getLogger()
+
+
+class TabListModel(PamhyrListModel):
+    def data(self, index, role):
+        row = index.row()
+        column = index.column()
+
+        checker = self._data[row]
+
+        if role == Qt.ForegroundRole:
+            color = Qt.gray
+            status = checker._status
+
+            if status is STATUS.OK:
+                color = Qt.green
+            elif status is STATUS.WARNING:
+                color = QColor("orange")
+            elif status is STATUS.ERROR:
+                color = Qt.red
+
+            return QBrush(color)
+
+        if role == Qt.ItemDataRole.DisplayRole:
+            msg = checker.name
+
+            if checker.is_error() or checker.is_warning():
+                msg += f": {checker.summary}"
+
+            return msg
+
+        return QVariant()
@@ -16,6 +16,9 @@

 # -*- coding: utf-8 -*-

+import logging
+
+from functools import reduce
 from tools import trace, timer

 from PyQt5.QtCore import (
@@ -35,9 +38,11 @@ from PyQt5.QtWidgets import (
    QComboBox,
 )

+from Modules import Modules
+from Checker.Checker import STATUS
 from View.Tools.PamhyrTable import PamhyrTableModel

-_translate = QCoreApplication.translate
+logger = logging.getLogger()


 class TableModel(PamhyrTableModel):
@@ -52,7 +57,7 @@ class TableModel(PamhyrTableModel):
                if self._data[row].is_ok():
                    color = Qt.green
                elif self._data[row].is_warning():
-                    color = Qt.yellow
+                    color = QColor("orange")
                elif self._data[row].is_error():
                    color = Qt.red

@@ -68,3 +73,92 @@ class TableModel(PamhyrTableModel):
            return self._data[row].summary

        return QVariant()
+
+
+class TabTableModel(PamhyrTableModel):
+    def _setup_lst(self):
+        self._lst = self._opt_data
+
+    def data(self, index, role):
+        row = index.row()
+        column = index.column()
+
+        if role == Qt.ForegroundRole:
+            if self._headers[column] == "type":
+                return QVariant()
+
+            color = Qt.gray
+            status, _ = self.compute_status(row, column)
+
+            if status is STATUS.OK:
+                color = Qt.green
+            elif status is STATUS.WARNING:
+                color = QColor("orange")
+            elif status is STATUS.ERROR:
+                color = Qt.red
+
+            return QBrush(color)
+
+        if role == Qt.ItemDataRole.DisplayRole:
+            if self._headers[column] == "type":
+                return self.module_display_name(self._opt_data[row])
+
+            value = "UNKNOWN"
+            status, _ = self.compute_status(row, column)
+
+            if status is STATUS.OK:
+                value = "OK"
+            elif status is STATUS.WARNING:
+                value = "WARNING"
+            elif status is STATUS.ERROR:
+                value = "ERROR"
+
+            return value
+
+        return QVariant()
+
+    def module_display_name(self, module):
+        return Modules.modelling_display_name()[module]
+
+    def get_checkers(self, row, column):
+        module = self._opt_data[row]
+        solver = self._headers[column]
+
+        checkers = filter(
+            lambda checker: checker._modules is module,
+            filter(
+                lambda checker: checker._solver is solver,
+                self._data
+            )
+        )
+
+        return checkers
+
+    def get_checkers_from_indexes(self, indexes):
+        lst = []
+
+        for index in indexes:
+            row = index.row()
+            column = index.column()
+
+            lst += list(self.get_checkers(row, column))
+
+        return lst
+
+    def compute_status(self, row, column):
+        checkers = self.get_checkers(row, column)
+
+        checkers_status = list(
+            map(
+                lambda c: c._status,
+                checkers
+            )
+        )
+
+        status = STATUS.UNKNOWN
+        if len(checkers_status) > 0:
+            status = reduce(lambda acc, c: acc | c, checkers_status)
+
+        logger.debug(f"Checkers: {row}, {column}: {checkers_status} {status}")
+
+        return status, checkers_status
@@ -18,12 +18,12 @@

 from PyQt5.QtCore import QCoreApplication

-from View.Tools.PamhyrTranslate import PamhyrTranslate
+from View.Translate import MainTranslate

 _translate = QCoreApplication.translate


-class CheckListTranslate(PamhyrTranslate):
+class CheckListTranslate(MainTranslate):
    def __init__(self):
        super(CheckListTranslate, self).__init__()

@@ -32,6 +32,6 @@ class CheckListTranslate(PamhyrTranslate):
        )

        self._sub_dict["table_headers"] = {
-            "name": _translate("CheckList", "Name"),
+            "name": self._dict["name"],
            "status": _translate("CheckList", "Status"),
        }
@@ -17,11 +17,14 @@
 # -*- coding: utf-8 -*-

 import time
+import logging

 from PyQt5.QtCore import (
    Qt, QObject, pyqtSlot, pyqtSignal
 )

+logger = logging.getLogger()
+

 class Worker(QObject):
    signalStatus = pyqtSignal(str)
@@ -43,6 +46,38 @@ class Worker(QObject):
            self.signalStatus.emit(checker.name)

            # Run checker
-            checker._run(self._study)
+            checker.run(self._study)

            self.signalStatus.emit("progress")
+
+
+class TabWorker(QObject):
+    signalStatus = pyqtSignal(str)
+
+    def __init__(self, study, checker_q, parent=None):
+        super(self.__class__, self).__init__(parent)
+
+        self._study = study
+        self._checker_q = checker_q
+
+    @property
+    def study(self):
+        return self._study
+
+    @study.setter
+    def study(self, study):
+        self._study = study
+
+    def process(self):
+        self._compute()
+
+    def _compute(self):
+        while True:
+            checker = self._checker_q.get()
+
+            if self._study is None:
+                self._checker_q.put(checker)
+                time.sleep(5)
+            else:
+                checker.run(self._study)
+                self.signalStatus.emit("progress")
@@ -18,12 +18,12 @@

 from PyQt5.QtCore import QCoreApplication

-from View.Tools.PamhyrTranslate import PamhyrTranslate
+from View.Translate import MainTranslate

 _translate = QCoreApplication.translate


-class ConfigureTranslate(PamhyrTranslate):
+class ConfigureTranslate(MainTranslate):
    def __init__(self):
        super(ConfigureTranslate, self).__init__()

@@ -32,9 +32,9 @@ class ConfigureTranslate(PamhyrTranslate):
        )

        self._sub_dict["table_headers"] = {
-            "name": _translate("Configure", "Name"),
-            "type": _translate("Configure", "Type"),
-            "description": _translate("Configure", "Description"),
+            "name": self._dict["name"],
+            "type": self._dict["type"],
+            "description": self._dict["description"],
        }

        # Solvers
@@ -45,6 +45,7 @@ from PyQt5.QtWidgets import (
    QComboBox, QUndoStack, QShortcut, QHeaderView,
 )

+from Modules import Modules
 from Solver.Solvers import solver_long_name

 logger = logging.getLogger()
@@ -123,11 +124,11 @@ class ConfigureWindow(PamhyrDialog):
    def setup_data(self):
        # Backup
        self.set_check_box("checkBox_backup", self._config.backup_enable)
-        self.set_line_edit_text("lineEdit_backup_path",
-                                self._config.backup_path)
+        # self.set_line_edit_text("lineEdit_backup_path",
+        #                         self._config.backup_path)
        self.set_time_edit("timeEdit_backup_frequence",
                           self._config.backup_frequence)
-        self.set_spin_box("spinBox_backup_max", self._config.backup_max)
+        # self.set_spin_box("spinBox_backup_max", self._config.backup_max)

        # Editor
        self.set_line_edit_text("lineEdit_editor_cmd",
@@ -155,12 +156,12 @@ class ConfigureWindow(PamhyrDialog):
            "pushButton_stricklers_del": self.del_stricklers,
            "pushButton_stricklers_sort": self.sort_stricklers,
            # Others
-            "pushButton_backup_path": lambda: self.file_dialog(
-                select_file=False,
-                callback=lambda f: self.set_line_edit_text(
-                    "lineEdit_backup_path", f[0]
-                )
-            ),
+            # "pushButton_backup_path": lambda: self.file_dialog(
+            #     select_file=False,
+            #     callback=lambda f: self.set_line_edit_text(
+            #         "lineEdit_backup_path", f[0]
+            #     )
+            # ),
        }

        for button in buttons:
@@ -172,11 +173,12 @@ class ConfigureWindow(PamhyrDialog):

        # Backup
        self._config.backup_enable = self.get_check_box("checkBox_backup")
-        self._config.backup_path = self.get_line_edit_text(
-            "lineEdit_backup_path")
+        # self._config.backup_path = self.get_line_edit_text(
+        #     "lineEdit_backup_path")
        self._config.backup_frequence = self.get_time_edit(
-            "timeEdit_backup_frequence")
-        self._config.backup_max = self.get_spin_box("spinBox_backup_max")
+            "timeEdit_backup_frequence"
+        )
+        # self._config.backup_max = self.get_spin_box("spinBox_backup_max")

        # Stricklers
        self._config.stricklers = deepcopy(self._stricklers)
@@ -188,6 +190,9 @@ class ConfigureWindow(PamhyrDialog):
        self._config.lang = Config.languages(
        )[self.get_combobox_text("comboBox_language")]

+        self._propagate_update(key=Modules.CONFIG)
+
+        self._config.save()
        self.end()

    def reject(self):
@@ -195,7 +200,6 @@ class ConfigureWindow(PamhyrDialog):
        self.end()

    def end(self):
-        self._config.save()
        self.close()

    # Debug
@@ -77,30 +77,10 @@ class ReplWindow(PamhyrWindow):
        layout.insertWidget(0, self._editor)

    def setup_connections(self):
-        self._hup_sc = QShortcut(QKeySequence("ctrl+Up"), self)
-        self._hdown_sc = QShortcut(QKeySequence("ctrl+Down"), self)
-        self._hup_sc.activated.connect(self.history_up)
-        self._hdown_sc.activated.connect(self.history_down)
-
        self.find(QPushButton, "pushButton").clicked.connect(self.eval_python)

-    def history_up(self):
-        if self._history_ind < len(self._history):
-            self._history_ind += 1
-            self._editor.setText(self._history[-self._history_ind])
-
-    def history_down(self):
-        if self._history_ind > 0:
-            self._history_ind -= 1
-            self._editor.setText(self._history[-self._history_ind])
-        else:
-            self._editor.setText("")
-
    def eval_python(self):
        code = self._editor.text()
-        self._history.append(code)
-        self._editor.setText("")
-        self._history_ind = 0

        # Code to rich_code
        rich_code = code.strip().split("\n")
@@ -50,7 +50,7 @@ class DocWindow(PamhyrWindow):
        return os.path.abspath(
            os.path.join(
                os.path.dirname(__file__),
-                "..", "..", "..", "..", "doc", filename
+                "..", "..", "..", "doc", filename
            )
        )

@@ -0,0 +1,50 @@
+# PlotRKC.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.HydraulicStructures.PlotRKC import PlotRKC
+
+_translate = QCoreApplication.translate
+
+
+class PlotRKZ(PlotRKC):
+    def __init__(self, canvas=None, trad=None, toolbar=None,
+                 river=None, reach=None, profile=None,
+                 parent=None):
+        super(PlotRKC, self).__init__(
+            canvas=canvas,
+            trad=trad,
+            data=river,
+            toolbar=toolbar,
+            parent=parent
+        )
+
+        self._current_reach = reach
+        self._current_profile = profile
+
+        self.label_x = self._trad["unit_rk"]
+        self.label_y = self._trad["unit_elevation"]
+
+        self._isometric_axis = False
+
+        self._auto_relim_update = True
+        self._autoscale_update = True
+        self.parent = parent
+
+    def onpick(self, event):
+        return
@@ -41,10 +41,10 @@ class PlotStricklers(PamhyrPlot):
            parent=parent
        )

-        self.label_x = self._trad["kp"]
-        self.label_y = self._trad["stricklers"]
+        self.label_x = self._trad["rk"]
+        self.label_y = self._trad["strickler_plot"]

-        self.line_kp_elevation = [None, None]
+        self.line_rk_elevation = [None, None]

        self._isometric_axis = False

@@ -65,9 +65,9 @@ class PlotStricklers(PamhyrPlot):
        self._init = True

    def draw_data(self):
-        kp = self.data.reach.get_kp()
+        rk = self.data.reach.get_rk()
        self.canvas.axes.set_xlim(
-            left=min(kp), right=max(kp)
+            left=min(rk), right=max(rk)
        )

        frictions = self.data.frictions
@@ -76,14 +76,14 @@ class PlotStricklers(PamhyrPlot):
            self.draw_frictions(lst, self.color_plot)

            # HightLight
-            kp_min, kp_max = (-1, -1)
+            rk_min, rk_max = (-1, -1)
            if self._highlight_data is not None:
-                kp_min, kp_max = self._highlight_data
+                rk_min, rk_max = self._highlight_data

                lst = list(
                    filter(
-                        lambda s: (s.begin_kp == kp_min and
-                                   s.end_kp == kp_max),
+                        lambda s: (s.begin_rk == rk_min and
+                                   s.end_rk == rk_max),
                        frictions.frictions
                    )
                )
@@ -96,7 +96,7 @@ class PlotStricklers(PamhyrPlot):
                lambda f: f.is_full_defined(),
                frictions
            ),
-            key=lambda s: s.begin_kp
+            key=lambda s: s.begin_rk
        )

        coef = flatten(
@@ -106,9 +106,9 @@ class PlotStricklers(PamhyrPlot):
            )
        )

-        kp = flatten(
+        rk = flatten(
            map(
-                lambda s: [s.begin_kp, s.end_kp],
+                lambda s: [s.begin_rk, s.end_rk],
                lst
            )
        )
@@ -116,13 +116,13 @@ class PlotStricklers(PamhyrPlot):
        coef_minor = list(map(lambda s: s.minor, coef))
        coef_medium = list(map(lambda s: s.medium, coef))

-        self.line_kp_elevation[0] = self.canvas.axes.plot(
-            kp, coef_minor,
+        self.line_rk_elevation[0] = self.canvas.axes.plot(
+            rk, coef_minor,
            color=color, lw=1.
        )

-        self.line_kp_elevation[1] = self.canvas.axes.plot(
-            kp, coef_medium,
+        self.line_rk_elevation[1] = self.canvas.axes.plot(
+            rk, coef_medium,
            color=color, lw=1.
        )

@@ -52,11 +52,12 @@ _translate = QCoreApplication.translate

 class ComboBoxDelegate(QItemDelegate):
    def __init__(self, data=None, study=None,
-                 mode="stricklers", parent=None):
+                 mode="stricklers", trad=None, parent=None):
        super(ComboBoxDelegate, self).__init__(parent)

        self._data = data
        self._study = study
+        self._trad = trad
        self._mode = mode

    def createEditor(self, parent, option, index):
@@ -64,7 +65,7 @@ class ComboBoxDelegate(QItemDelegate):

        if self._mode == "stricklers":
            self.editor.addItems(
-                [_translate("Frictions", "Not defined")] +
+                [self._trad["not_defined"]] +
                list(
                    map(
                        lambda s: str(s),
@@ -112,19 +113,19 @@ class TableModel(PamhyrTableModel):

        if self._headers[column] == "name":
            return self._lst.get(row).name
-        elif self._headers[column] == "begin_kp":
-            return self._lst.get(row).begin_kp
-        elif self._headers[column] == "end_kp":
-            return self._lst.get(row).end_kp
+        elif self._headers[column] == "begin_rk":
+            return self._lst.get(row).begin_rk
+        elif self._headers[column] == "end_rk":
+            return self._lst.get(row).end_rk
        elif self._headers[column] == "begin_strickler":
            value = self._lst.get(row).begin_strickler
            if value is None:
-                return _translate("Frictions", "Not defined")
+                return self._trad["not_defined"]
            return str(value)
        elif self._headers[column] == "end_strickler":
            value = self._lst.get(row).end_strickler
            if value is None:
-                return _translate("Frictions", "Not defined")
+                return self._trad["not_defined"]
            return str(value)

        return QVariant()
@@ -143,13 +144,13 @@ class TableModel(PamhyrTableModel):
                        self._lst, row, value
                    )
                )
-            elif self._headers[column] == "begin_kp":
+            elif self._headers[column] == "begin_rk":
                self._undo.push(
                    SetBeginCommand(
                        self._lst, row, value
                    )
                )
-            elif self._headers[column] == "end_kp":
+            elif self._headers[column] == "end_rk":
                self._undo.push(
                    SetEndCommand(
                        self._lst, row, value
@@ -49,14 +49,14 @@ class SetBeginCommand(QUndoCommand):

        self._frictions = frictions
        self._index = index
-        self._old = self._frictions.get(self._index).begin_kp
+        self._old = self._frictions.get(self._index).begin_rk
        self._new = float(new_value)

    def undo(self):
-        self._frictions.get(self._index).begin_kp = float(self._old)
+        self._frictions.get(self._index).begin_rk = float(self._old)

    def redo(self):
-        self._frictions.get(self._index).begin_kp = float(self._new)
+        self._frictions.get(self._index).begin_rk = float(self._new)


 class SetEndCommand(QUndoCommand):
@@ -65,14 +65,14 @@ class SetEndCommand(QUndoCommand):

        self._frictions = frictions
        self._index = index
-        self._old = self._frictions.get(self._index).end_kp
+        self._old = self._frictions.get(self._index).end_rk
        self._new = float(new_value)

    def undo(self):
-        self._frictions.get(self._index).end_kp = float(self._old)
+        self._frictions.get(self._index).end_rk = float(self._old)

    def redo(self):
-        self._frictions.get(self._index).end_kp = float(self._new)
+        self._frictions.get(self._index).end_rk = float(self._new)


 class SetBeginStricklerCommand(QUndoCommand):
@@ -39,6 +39,8 @@ from PyQt5.QtWidgets import (
    QComboBox, QVBoxLayout, QHeaderView, QTabWidget,
 )

+from Modules import Modules
+
 from View.Frictions.UndoCommand import (
    PasteCommand, DuplicateCommand,
 )
@@ -48,7 +50,7 @@ from View.Frictions.Table import (
 )

 from View.Tools.Plot.PamhyrCanvas import MplCanvas
-from View.Geometry.PlotKPZ import PlotKPZ
+from View.Frictions.PlotRKZ import PlotRKZ
 from View.Frictions.PlotStricklers import PlotStricklers
 from View.Frictions.translate import FrictionsTranslate

@@ -99,6 +101,7 @@ class FrictionsWindow(PamhyrWindow):
            data=self._reach,
            study=self._study,
            mode="stricklers",
+            trad=self._trad,
            parent=self
        )

@@ -107,7 +110,7 @@ class FrictionsWindow(PamhyrWindow):
            table_view=table,
            table_headers=self._trad.get_dict("table_headers"),
            editable_headers=[
-                "name", "begin_kp", "end_kp",
+                "name", "begin_rk", "end_rk",
                "begin_strickler", "end_strickler"
            ],
            delegates={
@@ -115,6 +118,7 @@ class FrictionsWindow(PamhyrWindow):
                "end_strickler": self._delegate_stricklers,
            },
            data=self._reach,
+            trad=self._trad,
            undo=self._undo_stack,
            opt_data=self._study
        )
@@ -129,11 +133,13 @@ class FrictionsWindow(PamhyrWindow):
        self.plot_layout = self.find(QVBoxLayout, "verticalLayout")
        self.plot_layout.addWidget(self.canvas)

-        self.plot = PlotKPZ(
+        self.plot = PlotRKZ(
            canvas=self.canvas,
-            data=self._reach.reach,
+            reach=self._reach,
+            river=self._study.river,
            trad=self._trad,
            toolbar=None,
+            parent=self
        )
        self.plot.draw()

@@ -179,10 +185,10 @@ class FrictionsWindow(PamhyrWindow):

    def update(self):
        self._set_current_reach()
-        # self._propagate_update(key="friction")
+        # self._propagate_update(key=Modules.FRICTION)

-    def _propagated_update(self, key=None):
-        if key != "geometry":
+    def _propagated_update(self, key=Modules(0)):
+        if Modules.GEOMETRY not in key:
            return

        self.update_plot()
@@ -198,7 +204,7 @@ class FrictionsWindow(PamhyrWindow):
            data = self._reach
            reach = self._reach.reach
            sec = self._frictions.get(rows[0])
-            highlight = (sec.begin_kp, sec.end_kp)
+            highlight = (sec.begin_rk, sec.end_rk)

        self.update_plot(highlight)

@@ -18,17 +18,18 @@

 from PyQt5.QtCore import QCoreApplication

-from View.Tools.PamhyrTranslate import PamhyrTranslate
+from View.Translate import MainTranslate

 _translate = QCoreApplication.translate


-class FrictionsTranslate(PamhyrTranslate):
+class FrictionsTranslate(MainTranslate):
    def __init__(self):
        super(FrictionsTranslate, self).__init__()

-        self._dict["kp"] = _translate(
-            "Frictions", "Kp (m)"
+        self._dict["rk"] = self._dict["unit_rk"]
+        self._dict["strickler_plot"] = _translate(
+            "Frictions", "Strickler ($m^{1/3}/s$)"
        )
        self._dict["stricklers"] = _translate(
            "Frictions", "Stricklers"
@@ -39,10 +40,10 @@ class FrictionsTranslate(PamhyrTranslate):
        )

        self._sub_dict["table_headers"] = {
-            # "name": _translate("Frictions", "Name"),
-            # "edge": _translate("Frictions", "Reach"),
-            "begin_kp": _translate("Frictions", "Begin kp (m)"),
-            "end_kp": _translate("Frictions", "End kp (m)"),
-            "begin_strickler": _translate("Frictions", "Begin strickler"),
-            "end_strickler": _translate("Frictions", "End strickler"),
+            # "name": self._dict["name"],
+            # "edge": self._dict["reach"],
+            "begin_rk": _translate("Frictions", "Start (m)"),
+            "end_rk": _translate("Frictions", "End (m)"),
+            "begin_strickler": _translate("Frictions", "Start coefficient"),
+            "end_strickler": _translate("Frictions", "End coefficient"),
        }
@@ -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:
@@ -86,11 +76,11 @@ class MeshingDialog(PamhyrDialog):
    def _init_default_values_profiles(self):
        profiles = self.profiles

-        self.combobox_add_items("comboBox_begin_kp", profiles)
-        self.combobox_add_items("comboBox_end_kp", profiles)
+        self.combobox_add_items("comboBox_begin_rk", profiles)
+        self.combobox_add_items("comboBox_end_rk", profiles)

-        self.set_combobox_text("comboBox_begin_kp", profiles[0])
-        self.set_combobox_text("comboBox_end_kp", profiles[-1])
+        self.set_combobox_text("comboBox_begin_rk", profiles[0])
+        self.set_combobox_text("comboBox_end_rk", profiles[-1])

    @property
    def profiles(self):
@@ -108,9 +98,9 @@ class MeshingDialog(PamhyrDialog):
        name = profile.name

        if name == "":
-            name = f"{profile.kp}"
+            name = f"{profile.rk}"
        else:
-            name += f" ({profile.kp})"
+            name += f" ({profile.rk})"

        return name

@@ -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,21 +125,17 @@ class MeshingDialog(PamhyrDialog):
    def lplan(self):
        return self._lplan

-    @property
-    def lm(self):
-        return int(self._lm)
-
    @property
    def linear(self):
        return self._linear

    @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):
@@ -165,8 +151,8 @@ class MeshingDialog(PamhyrDialog):
        )
        self._linear = self.get_radio_button("radioButton_linear")

-        p1 = self.get_combobox_text("comboBox_begin_kp")
-        p2 = self.get_combobox_text("comboBox_end_kp")
+        p1 = self.get_combobox_text("comboBox_begin_rk")
+        p2 = self.get_combobox_text("comboBox_end_rk")

        self._begin_cs = self.profiles.index(p1)
        self._end_cs = self.profiles.index(p2)
@@ -174,9 +160,6 @@ class MeshingDialog(PamhyrDialog):
        self._begin_dir = self.get_combobox_text("comboBox_begin_gl")
        self._end_dir = self.get_combobox_text("comboBox_end_gl")

-        r_lm_dict = self._trad.get_dict("r_lm_dict")
-        self._lm = r_lm_dict[self.get_combobox_text("comboBox_lm")]
-
        super().accept()

    def reject(self):
@@ -21,12 +21,6 @@ import logging
 from tools import timer
 from View.Tools.PamhyrPlot import PamhyrPlot

-from PyQt5.QtCore import (
-    QCoreApplication
-)
-
-_translate = QCoreApplication.translate
-
 logger = logging.getLogger()


@@ -46,20 +40,12 @@ class PlotAC(PamhyrPlot):
        self._auto_relim_update = True
        self._autoscale_update = True

-        self.label_x = _translate(
-            "Geometry", "Transverse abscissa (m)"
-        )
-        self.label_y = _translate("Geometry", "Height (m)")
+        self.label_x = self._trad["transverse_abscissa"]
+        self.label_y = self._trad["unit_height"]

-        self.label_previous_plot_selected = _translate(
-            "Geometry", "Previous cross-section"
-        )
-        self.label_plot_selected = _translate(
-            "Geometry", "Cross-section"
-        )
-        self.label_next_plot_selected = _translate(
-            "Geometry", "Next cross-section"
-        )
+        self.label_previous_plot_selected = self._trad["prev_cs"]
+        self.label_plot_selected = self._trad["cs"]
+        self.label_next_plot_selected = self._trad["next_cs"]

        self.previous_plot_selected = None
        self.plot_selected = None
@@ -112,6 +98,7 @@ class PlotAC(PamhyrPlot):
            label=self.label_next_plot_selected,
            color=self.color_plot_next, lw=1.6, linestyle='--'
        )
+        self.canvas.axes.set_visible(False)

    def draw_gl(self):
        if self._current_data_update:
@@ -120,12 +107,16 @@ class PlotAC(PamhyrPlot):
            profile_id = 0

        profile = self.data.profile(profile_id)
+        if profile is None:
+            return
+
        station = profile.get_station()
        elevation = profile.z()
        gl = profile.names()

        self.annotation = []
        self.complete_gl, self.incomplete_gl = self.data.compute_guidelines()
+
        lcomplete = list(self.complete_gl)
        lincomplete = list(self.incomplete_gl)

@@ -143,7 +134,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[
@@ -174,6 +165,9 @@ class PlotAC(PamhyrPlot):
            self.draw()
            return

+        if self.data is None:
+            return
+
        self.update_current()
        self.update_gl()

@@ -185,6 +179,10 @@ class PlotAC(PamhyrPlot):
            previous_id = profile_id - 1
            next_id = profile_id + 1

+            self.previous_plot_selected.set_visible(False)
+            self.plot_selected.set_visible(False)
+            self.next_plot_selected.set_visible(False)
+
            self.previous_plot_selected.set_data([], [])
            self.plot_selected.set_data([], [])
            self.next_plot_selected.set_data([], [])
@@ -194,18 +192,23 @@ class PlotAC(PamhyrPlot):
                    self.data.profile(previous_id).get_station(),
                    self.data.profile(previous_id).z()
                )
+                self.previous_plot_selected.set_visible(True)

            if 0 <= profile_id < self.data.number_profiles:
                self.plot_selected.set_data(
                    self.data.profile(profile_id).get_station(),
                    self.data.profile(profile_id).z()
                )
+                self.plot_selected.set_visible(True)

            if 0 <= next_id < self.data.number_profiles:
                self.next_plot_selected.set_data(
                    self.data.profile(next_id).get_station(),
                    self.data.profile(next_id).z()
                )
+                self.next_plot_selected.set_visible(True)
+
+            self.canvas.axes.set_visible(True)

    def update_full(self):
        self.draw()
@@ -1,275 +0,0 @@
-# PlotKPC.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
-from View.Tools.PamhyrPlot import PamhyrPlot
-
-from PyQt5.QtCore import (
-    QCoreApplication
-)
-
-_translate = QCoreApplication.translate
-
-logger = logging.getLogger()
-
-
-class PlotKPZ(PamhyrPlot):
-    def __init__(self, canvas=None, trad=None, data=None, toolbar=None,
-                 parent=None):
-        super(PlotKPZ, self).__init__(
-            canvas=canvas,
-            trad=trad,
-            data=data,
-            toolbar=toolbar,
-            parent=parent
-        )
-
-        self._isometric_axis = False
-
-        self.line_kp_zgl = []
-        self.line_kp_zmin = None
-        self.line_kp_zmin_zmax = None
-        self.line_kp_zmin_zmax_highlight = None
-
-        self.label_x = _translate("MainWindow_reach", "Kp (m)")
-        self.label_y = _translate("MainWindow_reach", "Height (m)")
-
-        self.before_plot_selected = None
-        self.plot_selected = None
-        self.after_plot_selected = None
-
-    @timer
-    def draw(self):
-        self.init_axes()
-
-        if self.data is None:
-            return
-
-        if len(self.data.profiles) == 0:
-            return
-
-        profiles_defined = any(
-            filter(
-                lambda profile: len(profile) > 0,
-                self.data.profiles
-            )
-        )
-
-        if not profiles_defined:
-            self._init = False
-            return
-
-        self.draw_z_line()
-        self.draw_z_line_highlight()
-        self.draw_current()
-        self.draw_gl()
-        self.draw_bottom()
-
-        self.idle()
-        self._init = True
-
-    def draw_z_line(self):
-        kp = self.data.get_kp_complete_profiles()
-        z_min = self.data.get_z_min()
-        z_max = self.data.get_z_max()
-
-        self.line_kp_zmin_zmax = self.canvas.axes.vlines(
-            x=kp, ymin=z_min, ymax=z_max,
-            color=self.color_plot,
-            lw=1.
-        )
-
-    def draw_z_line_highlight(self):
-        if self._highlight_data is not None:
-            kp = self.data.get_kp_complete_profiles()
-            z_min = self.data.get_z_min()
-            z_max = self.data.get_z_max()
-
-            kp_min, kp_max = self._highlight_data
-
-            indexes = list(
-                map(
-                    lambda x: x[0],
-                    filter(
-                        lambda x: kp_min <= x[1] <= kp_max,
-                        enumerate(kp)
-                    )
-                )
-            )
-
-            def indexes_filter(data): return list(
-                map(
-                    lambda x: x[1],
-                    filter(
-                        lambda x: x[0] in indexes,
-                        enumerate(data)
-                    )
-                )
-            )
-
-            ikp = indexes_filter(kp)
-            imin = indexes_filter(z_min)
-            imax = indexes_filter(z_max)
-
-            self.line_kp_zmin_zmax_highlight = self.canvas.axes.vlines(
-                x=ikp,
-                ymin=imin, ymax=imax,
-                color=self.color_plot_highlight,
-                lw=1.
-            )
-
-    def draw_current(self):
-        kp = self.data.get_kp_complete_profiles()
-        z_min = self.data.get_z_min()
-        z_max = self.data.get_z_max()
-
-        self.plot_selected, = self.canvas.axes.plot(
-            (kp[0], kp[0]),
-            (z_min[0], z_max[0]),
-            color=self.color_plot_current, lw=1.5
-        )
-        self.plot_selected.set_visible(False)
-
-        self.before_plot_selected, = self.canvas.axes.plot(
-            (kp[0], kp[0]),
-            (z_min[0], z_max[0]),
-            color=self.color_plot_previous, lw=1.5, linestyle='--'
-        )
-        self.before_plot_selected.set_visible(False)
-
-        self.after_plot_selected, = self.canvas.axes.plot(
-            (kp[0], kp[0]),
-            (z_min[0], z_max[0]),
-            color=self.color_plot_next, lw=1.5, linestyle='--'
-        )
-        self.after_plot_selected.set_visible(False)
-
-    def draw_gl(self):
-        kp = self.data.get_kp_complete_profiles()
-
-        ind = 0
-        self.line_kp_zgl = []
-        for z in self.data.get_guidelines_z():
-            # Is incomplete guideline?
-            if len(z) != len(kp):
-                continue
-
-            self.line_kp_zgl.append(
-                self.canvas.axes.plot(
-                    kp, z, lw=1., color=self.colors[ind]
-                )
-            )
-            ind += 1
-
-    def draw_bottom(self):
-        kp = self.data.get_kp_complete_profiles()
-        z_min = self.data.get_z_min()
-
-        self.line_kp_zmin, = self.canvas.axes.plot(
-            kp, z_min,
-            linestyle=":", lw=1.5,
-            color='lightgrey'
-        )
-
-    @timer
-    def update(self):
-        if not self._init:
-            self.draw()
-            return
-
-        self.update_gl()
-        self.update_current()
-
-        self.update_idle()
-
-    def update_current(self):
-        if self._current_data_update:
-            ind = self._current_data
-            before = ind - 1
-            after = ind + 1
-
-            self.before_plot_selected.set_visible(False)
-            self.plot_selected.set_visible(False)
-            self.after_plot_selected.set_visible(False)
-
-            if 0 <= before < self.data.number_profiles:
-                profile = self.data.profile(before)
-                if len(profile) > 0:
-                    kp_i = profile.kp
-                    z_min_i = profile.z_min()
-                    z_max_i = profile.z_max()
-
-                    self.before_plot_selected.set_data(
-                        (kp_i, kp_i),
-                        (z_min_i, z_max_i)
-                    )
-                    self.before_plot_selected.set_visible(True)
-
-            if 0 <= ind < self.data.number_profiles:
-                profile = self.data.profile(ind)
-                if len(profile) > 0:
-                    kp_i = profile.kp
-                    z_min_i = profile.z_min()
-                    z_max_i = profile.z_max()
-
-                    self.plot_selected.set_data(
-                        (kp_i, kp_i),
-                        (z_min_i, z_max_i)
-                    )
-                    self.plot_selected.set_visible(True)
-
-            if 0 <= after < self.data.number_profiles:
-                profile = self.data.profile(after)
-                if len(profile) > 0:
-                    kp_i = profile.kp
-                    z_min_i = profile.z_min()
-                    z_max_i = profile.z_max()
-
-                    self.after_plot_selected.set_data(
-                        (kp_i, kp_i),
-                        (z_min_i, z_max_i)
-                    )
-                    self.after_plot_selected.set_visible(True)
-
-    def update_gl(self):
-        if self._current_data_update:
-            return
-
-        kp = self.data.get_kp_complete_profiles()
-        z_min = self.data.get_z_min()
-        z_max = self.data.get_z_max()
-
-        self.line_kp_zmin.set_data(kp, z_min)
-
-        self.line_kp_zmin_zmax.remove()
-        self.line_kp_zmin_zmax = self.canvas.axes.vlines(
-            x=kp,
-            ymin=z_min, ymax=z_max,
-            color='r', lw=1.
-        )
-
-        z_complete = self.data.get_guidelines_z()
-        try:
-            for i in range(len(self.line_kp_zgl)):
-                self.line_kp_zgl[i][0].set_data(
-                    kp, z_complete[i]
-                )
-        except Exception as e:
-            logger.warning(f"Failed to update graphic KPZ: {e}")
@@ -0,0 +1,372 @@
+# PlotRKC.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
+from View.Tools.PamhyrPlot import PamhyrPlot
+from PyQt5.QtWidgets import QApplication
+from PyQt5.QtCore import (
+    Qt, QItemSelectionModel,
+    QItemSelection, QItemSelectionRange,
+)
+
+logger = logging.getLogger()
+
+
+class PlotRKZ(PamhyrPlot):
+    def __init__(self, canvas=None, trad=None,
+                 study=None, data=None, toolbar=None,
+                 table=None, parent=None):
+        self._study = study
+
+        super(PlotRKZ, self).__init__(
+            canvas=canvas,
+            trad=trad,
+            data=data,
+            toolbar=toolbar,
+            table=table,
+            parent=parent
+        )
+
+        self._isometric_axis = False
+
+        self.line_rk_zgl = []
+        self.line_rk_zmin = None
+        self.line_rk_zmin_zmax = None
+        self.line_rk_zmin_zmax_highlight = None
+
+        self.label_x = self._trad["unit_rk"]
+        self.label_y = self._trad["unit_height"]
+
+        self.before_plot_selected = None
+        self.plot_selected = None
+        self.after_plot_selected = None
+        self.parent = parent
+        self._table = table
+        self._colors = []
+
+    def onpick(self, event):
+        if event.mouseevent.inaxes != self.canvas.axes:
+            return
+        if event.mouseevent.button.value != 1:
+            return
+
+        modifiers = QApplication.keyboardModifiers()
+        if modifiers not in [Qt.ControlModifier,
+                             Qt.NoModifier,
+                             Qt.ShiftModifier]:
+            return
+
+        ind, point = self._closest_rk(event)
+        if self.parent._table is None:
+            return
+        self.parent._table.blockSignals(True)
+        if modifiers == Qt.ControlModifier:
+            rows = list(
+                set(
+                    (i.row() for i in self.parent.tableView.selectedIndexes())
+                )
+            )
+            if ind in rows:
+                rows.remove(ind)
+            else:
+                rows.append(ind)
+            self._select_in_table(rows)
+        elif modifiers == Qt.ShiftModifier:
+            rows = sorted(list(
+                set(
+                    (i.row() for i in self.parent.tableView.selectedIndexes())
+                )
+            ))
+            if len(rows) > 0:
+                i1 = min(rows[0], rows[-1], ind)
+                i2 = max(rows[0], rows[-1], ind)
+            else:
+                i1 = ind
+                i2 = ind
+            self._select_range_in_table(i1, i2)
+        else:
+            self._select_in_table([ind])
+        self.parent._table.blockSignals(False)
+
+        return
+
+    def _closest_rk(self, event):
+
+        s = event.artist.get_segments()
+        x = [i[0, 0] for i in s]
+        mx = event.mouseevent.xdata
+        points = enumerate(x)
+
+        def dist_mouse(point):
+            x = point[1]
+            d = abs(mx - x)
+            return d
+
+        closest = min(
+            points, key=dist_mouse
+        )
+
+        return closest
+
+    def _select_in_table(self, ind):
+        if self._table is None:
+            return
+
+        self._table.setFocus()
+        selection = self._table.selectionModel()
+        index = QItemSelection()
+
+        if len(ind) == 0:
+            return
+
+        for i in ind:
+            index.append(QItemSelectionRange(self._table.model().index(i, 0)))
+
+        selection.select(
+            index,
+            QItemSelectionModel.Rows |
+            QItemSelectionModel.ClearAndSelect |
+            QItemSelectionModel.Select
+        )
+
+        if len(ind) > 0:
+            self._table.scrollTo(self._table.model().index(ind[-1], 0))
+
+    def _select_range_in_table(self, ind1, ind2):
+        if self._table is not None:
+            self._table.setFocus()
+            selection = self._table.selectionModel()
+            index = QItemSelection(self._table.model().index(ind1, 0),
+                                   self._table.model().index(ind2, 0))
+            selection.select(
+                index,
+                QItemSelectionModel.Rows |
+                QItemSelectionModel.ClearAndSelect |
+                QItemSelectionModel.Select
+            )
+            self._table.scrollTo(self._table.model().index(ind2, 0))
+
+    @timer
+    def draw(self):
+        self.init_axes()
+
+        if self.data is None:
+            return
+
+        if len(self.data.profiles) == 0:
+            return
+
+        profiles_defined = any(
+            filter(
+                lambda profile: len(profile) > 0,
+                self.data.profiles
+            )
+        )
+
+        if not profiles_defined:
+            self._init = False
+            return
+
+        self.draw_z_line()
+        self.draw_lr()
+        self.draw_gl()
+        self.draw_bottom()
+        self.draw_profiles_hs(self._data)
+
+        self.idle()
+        self._init = True
+
+    def draw_z_line(self):
+        rk = self.data.get_rk_complete_profiles()
+        z_min = self.data.get_z_min()
+        z_max = self.data.get_z_max()
+
+        self._colors, self._style = self.color_hightlight()
+
+        self.line_rk_zmin_zmax = self.canvas.axes.vlines(
+            x=rk, ymin=z_min, ymax=z_max,
+            color=self._colors,
+            linestyle=self._style,
+            lw=1.,
+            picker=10,
+        )
+
+    def color_hightlight(self):
+        rows = sorted(list(
+            set(
+                (i.row() for i in self.parent.tableView.selectedIndexes())
+            )
+        ))
+        colors = [self.color_plot for row in range(len(self._data))]
+        style = ["-" for row in range(len(self._data))]
+        if len(rows) > 0:
+            for row in rows:
+                colors[row] = self.color_plot_current
+            if rows[0] > 0:
+                colors[rows[0]-1] = self.color_plot_previous
+                style[rows[0]-1] = "--"
+            if rows[-1] < len(self._data)-1:
+                colors[rows[-1]+1] = self.color_plot_next
+                style[rows[-1]+1] = "--"
+        return colors, style
+
+    def draw_lr(self):
+        rk = self.data.get_rk_complete_profiles()
+        lz = []
+        rz = []
+
+        self.line_lr = []
+        for z in self.data.get_z():
+            lz.append(z[0])
+            rz.append(z[-1])
+
+        line = self.canvas.axes.plot(
+            rk, lz,
+            color=self.color_plot_river_bottom,
+            linestyle="dotted",
+            lw=1.,
+        )
+        self.line_lr.append(line)
+
+        line = self.canvas.axes.plot(
+            rk, rz,
+            color=self.color_plot_river_bottom,
+            linestyle="dotted",
+            lw=1.,
+        )
+        self.line_lr.append(line)
+
+    def draw_gl(self):
+        rk = self.data.get_rk_complete_profiles()
+
+        ind = 0
+        self.line_rk_zgl = []
+        for z in self.data.get_guidelines_z():
+            # Is incomplete guideline?
+            if len(z) != len(rk):
+                continue
+
+            self.line_rk_zgl.append(
+                self.canvas.axes.plot(
+                    rk, z, lw=1.,
+                    color=self.colors[ind % len(self.colors)],
+                    linestyle=self.linestyle[ind // len(self.colors)]
+                )
+            )
+            ind += 1
+
+    def draw_bottom(self):
+        rk = self.data.get_rk_complete_profiles()
+        z_min = self.data.get_z_min()
+
+        self.line_rk_zmin, = self.canvas.axes.plot(
+            rk, z_min,
+            linestyle=":", lw=1.5,
+            color='lightgrey'
+        )
+
+    def draw_profiles_hs(self, reach):
+        lhs = filter(
+            lambda hs: hs._input_reach.reach is reach,
+            filter(
+                lambda hs: hs._input_reach is not None,
+                self._study.river.hydraulic_structures.lst
+            )
+        )
+
+        for hs in lhs:
+            x = hs.input_rk
+            if x is not None:
+                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:
+            self.draw()
+            return
+
+        self.update_lr()
+        self.update_gl()
+        self.update_current()
+
+        self.update_idle()
+
+    def update_current(self):
+        if self._current_data_update:
+            self._colors, self._style = self.color_hightlight()
+            self.line_rk_zmin_zmax.set_colors(self._colors)
+            self.line_rk_zmin_zmax.set_linestyle(self._style)
+
+    def update_gl(self):
+        if self._current_data_update:
+            return
+
+        rk = self.data.get_rk_complete_profiles()
+        z_min = self.data.get_z_min()
+        z_max = self.data.get_z_max()
+
+        self.line_rk_zmin.set_data(rk, z_min)
+
+#        TODO comprendre à quoi sert ce bout de code
+#        ========>
+#        self.line_rk_zmin_zmax.remove()
+#        self._colors, self._style = self.color_hightlight()
+#        self.line_rk_zmin_zmax = self.canvas.axes.vlines(
+#            x=rk,
+#            ymin=z_min,
+#            ymax=z_max,
+#            color=self._colors,
+#            linestyle = self._style,
+#            lw=1.
+#        )
+#        <========
+
+        z_complete = self.data.get_guidelines_z()
+        try:
+            for i in range(len(self.line_rk_zgl)):
+                self.line_rk_zgl[i][0].set_data(
+                    rk, z_complete[i]
+                )
+        except Exception as e:
+            logger.warning(f"Failed to update graphic RKZ: {e}")
+
+    def update_lr(self):
+        for line in self.line_lr:
+            line[0].remove()
+
+        self.draw_lr()
@@ -18,75 +18,233 @@

 from tools import timer, trace
 from View.Tools.PamhyrPlot import PamhyrPlot
+from matplotlib import collections
+import numpy as np

 from PyQt5.QtCore import (
-    QCoreApplication
+    QCoreApplication, Qt, QItemSelectionModel,
+    QItemSelection, QItemSelectionRange,
 )
+from PyQt5.QtWidgets import QApplication

 _translate = QCoreApplication.translate


 class PlotXY(PamhyrPlot):
    def __init__(self, canvas=None, trad=None, data=None, toolbar=None,
-                 parent=None):
+                 table=None, parent=None):
        super(PlotXY, self).__init__(
            canvas=canvas,
            trad=trad,
            data=data,
            toolbar=toolbar,
+            table=table,
            parent=parent
        )

        self.line_xy = []
        self.line_gl = []

-        self.label_x = _translate("Geometry", "X (m)")
-        self.label_y = _translate("Geometry", "Y (m)")
+        self.label_x = self._trad["x"]
+        self.label_y = self._trad["y"]

        self.before_plot_selected = None
        self.plot_selected = None
        self.after_plot_selected = None
+        self.parent = parent
+        self.line_xy_collection = None
+        self._table = table
+        self._colors = []
+        self._style = []
+
+    def onpick(self, event):
+        if event.mouseevent.inaxes != self.canvas.axes:
+            return
+        if event.mouseevent.button.value != 1:
+            return
+
+        modifiers = QApplication.keyboardModifiers()
+        if modifiers not in [Qt.ControlModifier,
+                             Qt.NoModifier,
+                             Qt.ShiftModifier]:
+            return
+
+        ind, point = self._closest_section(event)
+        if self._table is None:
+            return
+        self._table.blockSignals(True)
+        if modifiers == Qt.ControlModifier:
+            rows = list(
+                set(
+                    (i.row() for i in self.parent.tableView.selectedIndexes())
+                )
+            )
+            if ind in rows:
+                rows.remove(ind)
+                self._select_in_table(rows)
+            else:
+                self._select_in_table(rows + [ind])
+        elif modifiers == Qt.ShiftModifier:
+            rows = list(
+                set(
+                    (i.row() for i in self.parent.tableView.selectedIndexes())
+                )
+            )
+            if len(rows) > 0:
+                i1 = min(rows[0], rows[-1], ind)
+                i2 = max(rows[0], rows[-1], ind)
+            else:
+                i1 = ind
+                i2 = ind
+            self._select_range_in_table(i1, i2)
+        else:
+            self._select_in_table([ind])
+        self._table.blockSignals(False)
+
+        return
+
+    def _closest_section(self, event):
+        axes = self.canvas.axes
+        mx = event.mouseevent.xdata
+        my = event.mouseevent.ydata
+        bx, by = axes.get_xlim(), axes.get_ylim()
+        ratio = (bx[0] - bx[1]) / (by[0] - by[1])
+
+        segments = event.artist.get_segments()
+        ind = event.ind
+
+        points = []
+        for i in ind:
+            points = points + [[i, j] for j in segments[i]]
+
+        def dist_mouse(point):
+            x, y = point[1]
+            d2 = (((mx - x) / ratio) ** 2) + ((my - y) ** 2)
+            return d2
+
+        closest = min(
+            points, key=dist_mouse
+        )
+
+        return closest
+
+    def _select_in_table(self, ind):
+        if self._table is None:
+            return
+        self._table.setFocus()
+        selection = self._table.selectionModel()
+        index = QItemSelection()
+        if len(ind) == 0:
+            return
+        for i in ind:
+            index.append(QItemSelectionRange(self._table.model().index(i, 0)))
+        selection.select(
+            index,
+            QItemSelectionModel.Rows |
+            QItemSelectionModel.ClearAndSelect |
+            QItemSelectionModel.Select
+        )
+
+        if len(ind) > 0:
+            self._table.scrollTo(self._table.model().index(ind[-1], 0))
+
+    def _select_range_in_table(self, ind1, ind2):
+        if self._table is not None:
+            self._table.setFocus()
+            selection = self._table.selectionModel()
+            index = QItemSelection(self._table.model().index(ind1, 0),
+                                   self._table.model().index(ind2, 0))
+            selection.select(
+                index,
+                QItemSelectionModel.Rows |
+                QItemSelectionModel.ClearAndSelect |
+                QItemSelectionModel.Select
+            )
+            self._table.scrollTo(self._table.model().index(ind2, 0))

    @timer
    def draw(self):
        self.init_axes()

        if self.data is None:
+            self.idle()
            return

        if self.data.number_profiles == 0:
            self._init = False
+            self.idle()
            return

        self.draw_xy()
+        self.draw_lr()
        self.draw_gl()
-        self.draw_current()

        self.idle()
        self._init = True

    def draw_xy(self):
-        kp = self.data.get_kp_complete_profiles()
-
-        kp_min, kp_max = (-1, -1)
-        if self._highlight_data is not None:
-            kp_min, kp_max = self._highlight_data
-
-        def color_hightlight(kp):
-            if kp_min <= kp <= kp_max:
-                return self.color_plot_highlight
-            return self.color_plot
-
        self.line_xy = []
-        for x, y, kp in zip(self.data.get_x(),
-                            self.data.get_y(),
-                            kp):
-            line = self.canvas.axes.plot(
-                x, y,
-                color=color_hightlight(kp),
-                **self.plot_default_kargs
+        for xy in zip(self.data.get_x(), self.data.get_y()):
+            self.line_xy.append(np.column_stack(xy))
+
+        self._colors, self._style = self.color_hightlight()
+        self.line_xy_collection = collections.LineCollection(
+            self.line_xy,
+            colors=self._colors,
+            linestyle=self._style,
+            picker=10
+        )
+        self.canvas.axes.add_collection(self.line_xy_collection)
+
+    def color_hightlight(self):
+        rows = sorted(list(
+            set(
+                (i.row() for i in self.parent.tableView.selectedIndexes())
            )
-            self.line_xy.append(line)
+        ))
+        colors = [self.color_plot for row in range(len(self._data))]
+        style = ["-" for row in range(len(self._data))]
+        if len(rows) > 0:
+            for row in rows:
+                colors[row] = self.color_plot_current
+            if rows[0] > 0:
+                colors[rows[0]-1] = self.color_plot_previous
+                style[rows[0]-1] = "--"
+            if rows[-1] < len(self._data)-1:
+                colors[rows[-1]+1] = self.color_plot_next
+                style[rows[-1]+1] = "--"
+        return colors, style
+
+    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()
@@ -96,38 +254,12 @@ 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

-    def draw_current(self):
-        # Previous profile
-        self.before_plot_selected, = self.canvas.axes.plot(
-            self.data.profile(0).x(),
-            self.data.profile(0).y(),
-            color=self.color_plot_previous, linestyle="--",
-            **self.plot_default_kargs
-        )
-        self.before_plot_selected.set_visible(False)
-
-        # Current profile
-        self.plot_selected, = self.canvas.axes.plot(
-            self.data.profile(0).x(),
-            self.data.profile(0).y(),
-            color=self.color_plot_current, **self.plot_default_kargs
-        )
-        self.plot_selected.set_visible(False)
-
-        # Next profile
-        self.after_plot_selected, = self.canvas.axes.plot(
-            self.data.profile(0).x(),
-            self.data.profile(0).y(),
-            color=self.color_plot_next, linestyle='--',
-            **self.plot_default_kargs
-        )
-        self.after_plot_selected.set_visible(False)
-
    @timer
    def update(self):
        if not self._init:
@@ -137,6 +269,7 @@ class PlotXY(PamhyrPlot):
        if self.data is None:
            return

+        self.update_lr()
        self.update_gl()
        self.update_current()

@@ -147,21 +280,24 @@ class PlotXY(PamhyrPlot):
        x_complete = list(self.data.get_guidelines_x())
        y_complete = list(self.data.get_guidelines_y())

-        for i in range(self.data.number_profiles):
-            if i < len(self.line_xy):
-                self.line_xy[i][0].set_data(
-                    self.data.profile(i).x(),
-                    self.data.profile(i).y()
-                )
-            else:
-                self.line_xy.append(
-                    self.canvas.axes.plot(
-                        self.data.profile(i).x(),
-                        self.data.profile(i).y(),
-                        color='r',
-                        **self.plot_default_kargs
-                    )
-                )
+#        TODO comprendre à quoi sert ce bout de code
+#        ========>
+#        for i in range(self.data.number_profiles):
+#            if i < len(self.line_xy):
+#                self.line_xy[i][0].set_data(
+#                    self.data.profile(i).x(),
+#                    self.data.profile(i).y()
+#                )
+#            else:
+#                self.line_xy.append(
+#                    self.canvas.axes.plot(
+#                        self.data.profile(i).x(),
+#                        self.data.profile(i).y(),
+#                        color='r',
+#                        **self.plot_default_kargs
+#                    )
+#                )
+#        <========

        for i in range(len(x_complete)):
            if i < len(self.line_gl):
@@ -179,29 +315,12 @@ class PlotXY(PamhyrPlot):

    def update_current(self):
        if self._current_data_update:
-            ind = self._current_data
-            before = ind - 1
-            after = ind + 1
+            self._colors, self._style = self.color_hightlight()
+            self.line_xy_collection.set_colors(self._colors)
+            self.line_xy_collection.set_linestyle(self._style)

-            self.before_plot_selected.set_visible(False)
-            self.plot_selected.set_visible(False)
-            self.after_plot_selected.set_visible(False)
+    def update_lr(self):
+        for line in self.line_lr:
+            line[0].remove()

-            if 0 <= before < self.data.number_profiles:
-                self.before_plot_selected.set_data(
-                    self.data.profile(before).x(),
-                    self.data.profile(before).y()
-                )
-                self.before_plot_selected.set_visible(True)
-
-            if 0 <= ind < self.data.number_profiles:
-                self.plot_selected.set_data(self.data.profile(ind).x(),
-                                            self.data.profile(ind).y())
-                self.plot_selected.set_visible(True)
-
-            if 0 <= after < self.data.number_profiles:
-                self.after_plot_selected.set_data(
-                    self.data.profile(after).x(),
-                    self.data.profile(after).y()
-                )
-                self.after_plot_selected.set_visible(True)
+        self.draw_lr()
@@ -18,14 +18,19 @@

 import logging

+from math import dist, sqrt
+
 from tools import timer, trace
 from View.Tools.PamhyrPlot import PamhyrPlot
-from View.Tools.Plot.OnPickEvent import OnpickEvent

 from PyQt5.QtCore import (
-    QCoreApplication
+    Qt, QCoreApplication, QItemSelectionModel,
+    QItemSelection, QItemSelectionRange,
 )

+from PyQt5.QtWidgets import QApplication
+from matplotlib.widgets import RectangleSelector
+
 _translate = QCoreApplication.translate

 logger = logging.getLogger()
@@ -43,48 +48,289 @@ class Plot(PamhyrPlot):
        )

        self._table = table
+        self._parent = parent
+        self._z_note = None
+        self._z_line = None
+        self._z_fill_between = None

        self.line_xy = []
        self.line_gl = []

+        self.label_x = self._trad["unit_rk"]
+        self.label_y = self._trad["unit_height"]
+
        self.before_plot_selected = None
        self.plot_selected = None
        self.after_plot_selected = None

+        self._isometric_axis = False
+
+        self.hl_points = []
+        self.highlight = (
+            [],                 # Points list to highlight
+            None                # Hydrolic values (z, wet_area,
+                                # wet_preimeter, water_width)
+        )
+        self._onpickevent = None
+        self._rect_select = RectangleSelector(
+            ax=self.canvas.axes,
+            onselect=self.rect_select_callback,
+            useblit=True,
+            button=[1],  # don't use middle nor right button
+            minspanx=2.0,
+            minspany=2.0,
+            spancoords='pixels',
+            interactive=False
+        )
+
+    def onrelease(self, event):
+        # we need to do that to prevent conflicst
+        # between onpick and rect_select_callback
+        modifiers = QApplication.keyboardModifiers()
+        points, hyd = self.highlight
+        if self._onpickevent is not None:
+            ind, point = self._closest_point(self._onpickevent)
+            if modifiers == Qt.ControlModifier:
+                rows = self._parent.index_selected_rows()
+                if ind in rows:
+                    rows.remove(ind)
+                    del (points[ind])
+                    self.highlight = (points, hyd)
+                    self._select_in_table(rows)
+                else:
+                    self.highlight = (points+[point], hyd)
+                    self._select_in_table(rows+[ind])
+            elif modifiers == Qt.ShiftModifier:
+                rows = self._parent.index_selected_rows()
+                if len(rows) > 0:
+                    i1 = min(rows[0], rows[-1], ind)
+                    i2 = max(rows[0], rows[-1], ind)
+                    p = [
+                            [self.data.points[i].x, self.data.points[i].y]
+                            for i in range(i1, i2)
+                        ]
+                else:
+                    i1 = ind
+                    i2 = ind
+                    p = [point]
+                self.highlight = (p, hyd)
+                self._select_range_in_table(i1, i2)
+            else:
+                self.highlight = ([point], hyd)
+                self._select_in_table([ind])
+
+        self._onpickevent = None
+
+    def onpick(self, event):
+        if event.mouseevent.inaxes != self.canvas.axes:
+            return
+        if event.mouseevent.button.value != 1:
+            return
+
+        modifiers = QApplication.keyboardModifiers()
+        if modifiers not in [Qt.ControlModifier,
+                             Qt.NoModifier,
+                             Qt.ShiftModifier]:
+            return
+
+        self._onpickevent = event
+        return
+
+    def onclick(self, event):
+        if event.inaxes != self.canvas.axes:
+            return
+        if event.button.value == 1:
+            return
+
+        points, _ = self.highlight
+
+        z = self._get_z_from_click(event)
+        if z < self.data.z_min() or event.button.value == 2:
+            self.highlight = (points, None)
+            self.update()
+            return
+
+        a, p, w = self._compute_hydraulics(z)
+
+        logger.debug(f"{z, a, p, w}")
+
+        self.highlight = (points, (z, a, p, w))
+
+        self.update()
+        return
+
+    def select_points_from_indices(self, indices):
+        data = self.data
+        _, hyd = self.highlight
+
+        points = list(
+            map(
+                lambda e: e[1],
+                filter(
+                    lambda e: e[0] in indices,
+                    enumerate(
+                        zip(data.get_station(), data.z())
+                    )
+                )
+            )
+        )
+
+        self.highlight = (points, hyd)
+        self.update()
+
+    def _select_in_table(self, ind):
+        if self._table is not None:
+            self._table.blockSignals(True)
+            self._table.setFocus()
+            selection = self._table.selectionModel()
+            index = QItemSelection()
+            if len(ind) > 0:
+                for i in ind:
+                    index.append(QItemSelectionRange(
+                        self._table.model().index(i, 0))
+                    )
+            selection.select(
+                index,
+                QItemSelectionModel.Rows |
+                QItemSelectionModel.ClearAndSelect |
+                QItemSelectionModel.Select
+            )
+
+            if len(ind) > 0:
+                self._table.scrollTo(self._table.model().index(ind[-1], 0))
+            self._table.blockSignals(False)
+
+    def _select_range_in_table(self, ind1, ind2):
+        if self._table is not None:
+            self._table.blockSignals(True)
+            self._table.setFocus()
+            selection = self._table.selectionModel()
+            index = QItemSelection(self._table.model().index(ind1, 0),
+                                   self._table.model().index(ind2, 0))
+            selection.select(
+                index,
+                QItemSelectionModel.Rows |
+                QItemSelectionModel.ClearAndSelect |
+                QItemSelectionModel.Select
+            )
+            self._table.scrollTo(self._table.model().index(ind2, 0))
+            self._table.blockSignals(False)
+
+    def _closest_point(self, event):
+        points_ind = event.ind
+        axes = self.canvas.axes
+        bx, by = axes.get_xlim(), axes.get_ylim()
+        ratio = (bx[0] - bx[1]) / (by[0] - by[1])
+
+        x = event.artist.get_xdata()
+        y = event.artist.get_ydata()
+
+        # points = filter(
+        #     lambda e: e[0] in points_ind,
+        #     enumerate(zip(x, y))
+        # )
+        points = enumerate(zip(x, y))
+
+        mx = event.mouseevent.xdata
+        my = event.mouseevent.ydata
+
+        def dist_mouse(point):
+            x, y = point[1]
+            d2 = ((mx - x) / ratio) ** 2 + ((my - y) ** 2)
+            return d2
+
+        closest = min(
+            points, key=dist_mouse
+        )
+
+        return closest
+
+    def _get_z_from_click(self, event):
+        return event.ydata
+
+    def rect_select_callback(self, eclick, erelease):
+
+        points, hyd = self.highlight
+        x1, y1 = eclick.xdata, eclick.ydata
+        x2, y2 = erelease.xdata, erelease.ydata
+
+        if (max(abs(x1-x2), abs(y1-y2)) < 0.001):
+            return
+        modifiers = QApplication.keyboardModifiers()
+
+        x1, y1 = eclick.xdata, eclick.ydata
+        x2, y2 = erelease.xdata, erelease.ydata
+
+        inds, points2 = self._points_in_rectangle(x1, y1, x2, y2)
+        self._onclickevent = None
+        if modifiers == Qt.ControlModifier:
+            rows = self._parent.index_selected_rows()
+            if all(i in rows for i in inds):
+                for ind in sorted(inds, reverse=True):
+                    rows.remove(ind)
+                    del (points[ind])
+                self.highlight = (points, hyd)
+                self._select_in_table(rows)
+            else:
+                self.highlight = (points+points2, hyd)
+                self._select_in_table(rows+inds)
+        else:
+            self.highlight = (points2, hyd)
+            self._select_in_table(inds)
+        return
+
+    def _points_in_rectangle(self, x1, y1, x2, y2):
+        # TODO: use lambdas
+        listi = []
+        listp = []
+        station = self.data._get_station(self.data.points)
+        for i, p in enumerate(self.data.points):
+            if (min(x1, x2) < station[i] < max(x1, x2)
+                    and min(y1, y2) < p.z < max(y1, y2)):
+                listi.append(i)
+                listp.append((station[i], p.z))
+        return listi, listp
+
+    def _compute_hydraulics(self, z):
+        profile = self.data
+
+        points = profile.wet_points(z)
+        station = profile._get_station(points)
+        width = abs(station[0] - station[-1])
+
+        poly = profile.wet_polygon(z)
+        area = poly.area
+        perimeter = poly.length
+
+        return area, perimeter, width
+
    @timer
    def draw(self):
-        self.canvas.axes.cla()
-        self.canvas.axes.grid(
-            color='grey', linestyle='--', linewidth=0.5
-        )
+        self.init_axes()

        x = self.data.get_station()
        y = self.data.z()
        x_carto = self.data.x()
        y_carto = self.data.y()

-        if (len(x_carto) < 3 or len(y_carto) < 3 or
-                len(x) < 3):
+        if (len(x_carto) < 3 or len(y_carto) < 3 or len(x) < 3):
            # Noting to do in this case
            return

-        gl = map(lambda p: p.name, self.data.points)
-
        self.profile_line2D, = self.canvas.axes.plot(
-            x, y, color='r', lw=1.5,
-            markersize=7, marker='+',
-            picker=30
-        )
-        self.canvas.axes.set_xlabel(
-            _translate("MainWindowProfile",
-                       "Transverse abscissa (m)"),
-            color='black', fontsize=10
-        )
-        self.canvas.axes.set_ylabel(
-            _translate("MainWindowProfile", "Height (m)"),
-            color='black', fontsize=10
+            x, y, color=self.color_plot,
+            lw=1.5, markersize=7, marker='+',
+            picker=10
        )

+        self.draw_annotation(x, y)
+        self.draw_highligth()
+
+        self.idle()
+
+    def draw_annotation(self, x, y):
+        gl = map(lambda p: p.name, self.data.points)
+
        # Add label on graph
        self.annotation = []
        for i, name in enumerate(list(gl)):
@@ -120,32 +366,88 @@ class Plot(PamhyrPlot):
        self.canvas.axes.set_facecolor('#F9F9F9')
        self.canvas.figure.patch.set_facecolor('white')

-        self.onpick_event = OnpickEvent(
-            self.canvas.axes,
-            x, y, x_carto, y_carto,
-            self._table
-        )
-        self.canvas.figure.canvas\
-                          .mpl_connect(
-                              'pick_event',
-                              self.onpick_event.onpick
-                          )
+    def draw_highligth(self):
+        points, hyd = self.highlight
+        for p in self.hl_points:
+            p[0].set_data([], [])

-        self.onclick_event = OnpickEvent(
-            self.canvas.axes,
-            x, y, x_carto, y_carto,
-            self._table
-        )
-        self.canvas.figure.canvas\
-                          .mpl_connect(
-                              'button_press_event',
-                              self.onclick_event.onclick
-                          )
+        self.hl_points = []

-        self.canvas.figure.tight_layout()
-        self.canvas.figure.canvas.draw_idle()
+        for x, y in points:
+            self.hl_points.append(
+                self.canvas.axes.plot(
+                    x, y,
+                    color=self.color_plot_highlight,
+                    lw=1.5, markersize=7, marker='+',
+                )
+            )
+
+        if hyd is not None:
+            self.draw_highligth_z_line(*hyd)
+        else:
+            if self._z_note is not None:
+                self._z_note.set_visible(False)
+                self._z_line[0].set_visible(False)
+                self._z_fill_between.set_visible(False)
+
+    def draw_highligth_z_line(self, z, a, p, w):
+        text = (
+            f"Z = {z:.3f} m, " +
+            f"{self._trad['width']} = {w:.3f} m,\n" +
+            f"{self._trad['area']} = {a:.3f} m², " +
+            f"{self._trad['perimeter']} = {p:.3f} m"
+        )
+
+        x = self.data.get_station()
+        xlim = (x[0], x[-1])
+        pos = (
+            xlim[0] + (abs(xlim[0] - xlim[1]) * 0.05),
+            z + 0.8
+        )
+        y = self.data.z()
+
+        if self._z_note is None:
+            self.draw_highligth_z_line_fill(x, y, z)
+
+            self._z_line = self.canvas.axes.plot(
+                xlim, [z, z],
+                color=self.color_plot_river_water
+            )
+            self._z_line[0].set_visible(True)
+
+            self._z_note = self.canvas.axes.annotate(
+                text, pos,
+                horizontalalignment='left',
+                verticalalignment='top',
+                annotation_clip=True,
+                color=self.color_plot_river_water,
+                fontsize=9,
+                fontweight='bold',
+                alpha=0.7
+            )
+            self._z_note.set_visible(True)
+        else:
+            self.draw_highligth_z_line_fill(x, y, z)
+
+            self._z_line[0].set_data(xlim, [z, z])
+            self._z_note.set_position(pos)
+            self._z_note.set_text(text)
+            self._z_line[0].set_visible(True)
+            self._z_note.set_visible(True)
+
+    def draw_highligth_z_line_fill(self, x, y, z):
+        if self._z_fill_between is not None:
+            self._z_fill_between.remove()
+
+        self._z_fill_between = self.canvas.axes.fill_between(
+            x, y, z,
+            where=y <= z,
+            facecolor=self.color_plot_river_water_zone,
+            interpolate=True, alpha=0.7
+        )

    @timer
-    def update(self, ind=None):
-        logger.info("TODO: implemente update")
-        self.draw()
+    def update(self):
+        self.draw_highligth()
+
+        self.update_idle()
@@ -82,16 +82,6 @@ class GeometryProfileTableModel(PamhyrTableModel):
                    elif value == self._data.z_max():
                        return QColor("blue")

-                if role == Qt.ToolTipRole:
-                    if value == self._data.z_min():
-                        return _translate("MainWindowProfile",
-                                          "La cote du fond",
-                                          "Z minimale")
-                    elif value == self._data.z_max():
-                        return _translate("MainWindowProfile",
-                                          "La cote maximale",
-                                          "Z maximale")
-
            if index.column() == 3:
                value = self._data.point(index.row()).name

@@ -104,16 +94,6 @@ class GeometryProfileTableModel(PamhyrTableModel):
                    if role == Qt.ForegroundRole:
                        return QColor("darkRed")

-                    if role == Qt.ToolTipRole:
-                        if value.strip().upper() == "RG":
-                            return _translate(
-                                "MainWindowProfile", "Rive gauche"
-                            )
-                        else:
-                            return _translate(
-                                "MainWindowProfile", "Rive droite"
-                            )
-
        return QVariant()

    def setData(self, index, value, role=Qt.EditRole):
@@ -250,6 +230,26 @@ class GeometryProfileTableModel(PamhyrTableModel):
        self.endMoveRows()
        self.layoutChanged.emit()

+    def purge(self, np_purge):
+
+        self._undo.push(
+            PurgeCommand(
+                self._data, np_purge
+            )
+        )
+
+        self.layoutChanged.emit()
+
+    def reverse(self):
+
+        self._undo.push(
+            ReverseCommand(
+                self._data
+            )
+        )
+
+        self.layoutChanged.emit()
+
    def paste(self, row, header, data):
        if row > self._data.number_points:
            return
@@ -18,7 +18,7 @@

 from PyQt5.QtCore import QCoreApplication

-from View.Tools.PamhyrTranslate import PamhyrTranslate
+from View.Translate import MainTranslate
 from View.Geometry.Translate import GeometryTranslate

 _translate = QCoreApplication.translate
@@ -32,10 +32,14 @@ class GeometryProfileTranslate(GeometryTranslate):
            "Geometry", "Geometry cross-section"
        )

+        self._dict["width"] = _translate("Geometry", "Width")
+        self._dict["area"] = _translate("Geometry", "Area")
+        self._dict["perimeter"] = _translate("Geometry", "Perimeter")
+
        self._sub_dict["table_headers"] = {
-            "x": _translate("Geometry", "X (m)"),
-            "y": _translate("Geometry", "Y (m)"),
-            "z": _translate("Geometry", "Z (m)"),
-            "name": _translate("Geometry", "Name"),
+            "x": self._dict["x"],
+            "y": self._dict["y"],
+            "z": self._dict["z"],
+            "name": self._dict["name"],
            "abs": _translate("Geometry", "Traversal abs (m)"),
        }
@@ -169,6 +169,34 @@ class MoveCommand(QUndoCommand):
            self._profile.move_down_point(self._i)


+class ReverseCommand(QUndoCommand):
+    def __init__(self, profile):
+        QUndoCommand.__init__(self)
+
+        self._profile = profile
+
+    def undo(self):
+        self._profile.reverse()
+
+    def redo(self):
+        self._profile.reverse()
+
+
+class PurgeCommand(QUndoCommand):
+    def __init__(self, profile, np_purge):
+        QUndoCommand.__init__(self)
+
+        self._profile = profile
+        self._old = self._profile.points.copy()
+        self._np_purge = np_purge
+
+    def undo(self):
+        self._profile._points = self._old.copy()
+
+    def redo(self):
+        self._profile.purge(self._np_purge)
+
+
 class PasteCommand(QUndoCommand):
    def __init__(self, profile, row, points):
        QUndoCommand.__init__(self)
@@ -20,8 +20,10 @@ import copy
 import sys
 import csv
 from time import time
+import logging

-from tools import trace, timer
+from tools import trace, timer, logger_exception
+from Modules import Modules

 from PyQt5.QtGui import (
    QKeySequence,
@@ -45,9 +47,12 @@ from View.Tools.Plot.PamhyrCanvas import MplCanvas
 from View.Geometry.Profile.Plot import Plot
 from View.Geometry.Profile.Table import GeometryProfileTableModel
 from View.Geometry.Profile.Translate import GeometryProfileTranslate
+from View.Geometry.PurgeDialog import PurgeDialog

 _translate = QCoreApplication.translate

+logger = logging.getLogger()
+

 class ProfileWindow(PamhyrWindow):
    _pamhyr_ui = "GeometryCrossSection"
@@ -59,7 +64,7 @@ class ProfileWindow(PamhyrWindow):
        trad = GeometryProfileTranslate()
        name = (
            trad[self._pamhyr_name] +
-            f" - {self._profile.name} {self._profile.kp}"
+            f" - {self._profile.name} {self._profile.rk}"
        )

        super(ProfileWindow, self).__init__(
@@ -108,8 +113,10 @@ class ProfileWindow(PamhyrWindow):
        self._plot = Plot(
            canvas=self._canvas,
            data=self._profile,
+            trad=self._trad,
            toolbar=self._toolbar,
-            table=self.find(QTableView, "tableView")
+            table=self.find(QTableView, "tableView"),
+            parent=self
        )
        self._plot.draw()

@@ -123,26 +130,49 @@ class ProfileWindow(PamhyrWindow):
            "action_down": self.move_down,
            "action_add": self.add,
            "action_delete": self.delete,
+            "action_purge": self.purge,
+            "action_reverse": self.reverse,
        }

        for action in actions:
            self.find(QAction, action)\
                .triggered.connect(actions[action])

+        table = self.find(QTableView, f"tableView")
+        table.selectionModel()\
+             .selectionChanged\
+             .connect(self.update_points_selection)
+
        self._tablemodel.dataChanged.connect(self.update)

+    def update_points_selection(self):
+        rows = self.index_selected_rows()
+        self._plot.select_points_from_indices(rows)
+
    def update(self):
        self.update_plot()
-        self._propagate_update(key="geometry")
+        self._propagate_update(key=Modules.GEOMETRY)
+
+    def _update(self, redraw=False, propagate=True):
+        if redraw:
+            self.update_plot()
+        if propagate:
+            self._propagate_update(key=Modules.GEOMETRY)

    def update_plot(self):
        self._tablemodel.blockSignals(True)

-        # TODO: Do not rebuild all graph
        self._plot.update()

        self._tablemodel.blockSignals(False)

+    def _propagated_update(self, key=Modules(0)):
+        if Modules.GEOMETRY not in key:
+            return
+
+        self._tablemodel.layoutChanged.emit()
+        self._update(redraw=True, propagate=False)
+
    def index_selected_row(self):
        table = self.find(QTableView, "tableView")
        rows = table.selectionModel()\
@@ -152,6 +182,15 @@ class ProfileWindow(PamhyrWindow):

        return rows[0].row()

+    def index_selected_rows(self):
+        table = self.find(QTableView, "tableView")
+        return list(
+            map(
+                lambda r: r.row(),
+                table.selectionModel().selectedRows()
+            )
+        )
+
    def add(self):
        table = self.find(QTableView, "tableView")
        if len(table.selectedIndexes()) == 0:
@@ -219,6 +258,27 @@ class ProfileWindow(PamhyrWindow):

        self.update()

+    def purge(self):
+        self._tablemodel.purge()
+        self.update()
+
+    def purge(self):
+        try:
+            dlg = PurgeDialog(
+                trad=self._trad,
+                parent=self
+            )
+            if dlg.exec():
+                self._tablemodel.purge(dlg.np_purge)
+                self._plot.draw()
+        except Exception as e:
+            logger_exception(e)
+            return
+
+    def reverse(self):
+        self._tablemodel.reverse()
+        self.update()
+
    def _copy(self):
        table = self.find(QTableView, "tableView")
        rows = table.selectionModel().selectedRows()
@@ -0,0 +1,60 @@
+# PurgeDialog.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 View.Tools.PamhyrWindow import PamhyrDialog
+
+from PyQt5.QtGui import (
+    QKeySequence,
+)
+
+from PyQt5.QtCore import (
+    Qt, QVariant, QAbstractTableModel,
+)
+
+from PyQt5.QtWidgets import (
+    QUndoStack, QShortcut, QSpinBox,
+)
+
+
+class PurgeDialog(PamhyrDialog):
+    _pamhyr_ui = "PurgeOptions"
+    _pamhyr_name = "Purge"
+
+    def __init__(self, trad=None, parent=None):
+        super(PurgeDialog, self).__init__(
+            title=trad[self._pamhyr_name],
+            trad=trad,
+            options=[],
+            parent=parent
+        )
+
+        self._init_default_values()
+
+    def _init_default_values(self):
+        self._np_purge = 24
+
+    @property
+    def np_purge(self):
+        return self._np_purge
+
+    def accept(self):
+        self._np_purge = self.get_spin_box("spinBox_np_purge")
+        super().accept()
+
+    def reject(self):
+        self.close()
@@ -55,8 +55,8 @@ class GeometryReachTableModel(PamhyrTableModel):
            return self._data.profile(index.row()).name

        if role == Qt.DisplayRole and index.column() == 1:
-            kp = self._data.profile(index.row()).kp
-            return f"{kp:.4f}"
+            rk = self._data.profile(index.row()).rk
+            return f"{rk:.4f}"

        if role == Qt.DisplayRole and index.column() == 2:
            return str(self._data.profile(index.row()).nb_points)
@@ -94,9 +94,9 @@ class GeometryReachTableModel(PamhyrTableModel):

                if index.column() == 1:
                    self._undo.push(
-                        SetKPCommand(
+                        SetRKCommand(
                            self._data, index.row(),
-                            self._data.profile(index.row()).kp,
+                            self._data.profile(index.row()).rk,
                            value
                        )
                    )
@@ -240,9 +240,30 @@ class GeometryReachTableModel(PamhyrTableModel):

        self._undo.push(
            MeshingCommand(
-                self._data, mesher, data
+                self._data, mesher, data, "mesh"
            )
        )

        self.layoutAboutToBeChanged.emit()
        self.layoutChanged.emit()
+
+    def update_rk(self, mesher, data):
+        self.layoutAboutToBeChanged.emit()
+
+        self._undo.push(
+            MeshingCommand(
+                self._data, mesher, data, "update_rk"
+            )
+        )
+
+        self.layoutAboutToBeChanged.emit()
+        self.layoutChanged.emit()
+
+    def purge(self, np_purge):
+
+        self._undo.push(
+            PurgeCommand(
+                self._data, np_purge
+            )
+        )
+        self.layoutChanged.emit()