Translate: Add short RK name.

.gitlab-ci.yml

@@ -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
+    - curl -L -o mage8.tgz https://gitlab.irstea.fr/jean-baptiste.faure/mage/-/releases/$MAGE_8_VERSION/downloads/packages/mage_linux.tgz
-    - mkdir -p mage-linux
+    - mkdir -p mage8-linux
-    - cd mage-linux
+    - cd mage8-linux
-    - tar xvf ../mage.tgz
+    - tar xvf ../mage8.tgz
   artifacts:
     paths:
-      - mage-linux/mage
+      - mage8-linux/mage
-      - mage-linux/mage_extraire
+      - mage8-linux/mage_as7
-      - mage-linux/mailleurTT
+      - mage8-linux/mage_extraire
-      - mage-linux/libbief.so
+      - 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
+    - curl -L -o mage8.tgz https://gitlab.irstea.fr/jean-baptiste.faure/mage/-/releases/$MAGE_8_VERSION/downloads/packages/mage_windows.tgz
-    - mkdir -p mage-windows
+    - mkdir -p mage8-windows
-    - cd mage-windows
+    - cd mage8-windows
-    - tar xvf ../mage.tgz
+    - tar xvf ../mage8.tgz
   artifacts:
     paths:
-      - mage-windows/mage.exe
+      - mage8-windows/mage.exe
-      - mage-windows/mage_extraire.exe
+      - mage8-windows/mage_as7.exe
-      - mage-windows/mailleurTT.exe
+      - mage8-windows/mage_extraire.exe
-      - mage-windows/libbief.dll
+      - 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/_internal
-    - mkdir -p pamhyr/pamhyr/_internal
     # Copy Pamhyr info
-    - cp -v ../VERSION pamhyr/pamhyr/_internal/
+    - cp -v ../VERSION pamhyr/_internal/
-    - cp -v ../AUTHORS pamhyr/pamhyr/_internal/
+    - cp -v ../AUTHORS pamhyr/_internal/
-    - cp -v ../LICENSE pamhyr/pamhyr/_internal/
+    - cp -v ../LICENSE pamhyr/_internal/
-    - cp -v ../src/motd.txt pamhyr/pamhyr/_internal/
+    - cp -v ../src/motd.txt pamhyr/_internal/
     # Copy mage
-    - mkdir -p pamhyr/mage
+    - mkdir -p pamhyr/mage8
-    - cp -v ../mage-linux/* pamhyr/mage/
+    - 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/_internal/View
-    - mkdir -p pamhyr/pamhyr/_internal/View/ui
+    - mkdir -p pamhyr/_internal/View/ui
-    - mkdir -p pamhyr/pamhyr/_internal/View/ui/Widgets
+    - mkdir -p pamhyr/_internal/View/ui/Widgets
-    - cp -r ../src/View/ui/*.ui pamhyr/pamhyr/_internal/View/ui/
+    - cp -r ../src/View/ui/*.ui pamhyr/_internal/View/ui/
-    - cp -r ../src/View/ui/ressources/ pamhyr/pamhyr/_internal/View/ui
+    - cp -r ../src/View/ui/ressources/ pamhyr/_internal/View/ui
-    - cp -r ../src/View/ui/Widgets/*.ui pamhyr/pamhyr/_internal/View/ui/Widgets
+    - cp -r ../src/View/ui/Widgets/*.ui pamhyr/_internal/View/ui/Widgets
     # Copy lang
-    - mkdir -p pamhyr/pamhyr/_internal/lang
+    - mkdir -p pamhyr/_internal/lang
-    - cp -r ../src/lang/*.qm pamhyr/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

doc/dev/documentation.org

@@ -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.Tools.PamhyrWindow import PamhyrWindow
-    from View.My.Translate import MyTranslate
+  from View.My.Translate import MyTranslate
-    from View.My.Table import MyTableModel
+  from View.My.Table import MyTableModel
 
-    class MyWindow(PamhyrWindow):
+  class MyWindow(PamhyrWindow):
-        _pamhyr_ui = "MyUI"
+      _pamhyr_ui = "MyUI"
-        _pamhyr_name = "My window"
+      _pamhyr_name = "My window"
 
-        def __init__(self, my_data=None,
+      def __init__(self, study=None, config=None,
-                     study=None, config=None,
+                   my_data=None,
-                     parent=None):
+                   parent=None):
-            self._my_data = my_data
+          self._my_data = my_data
 
-            super(MyWindow, self).__init__(
+          super(MyWindow, self).__init__(
-                # Window title
+              # Window title
-                title = self._pamhyr_name + " - " + study.name,
+              title = self._pamhyr_name + " - " + study.name,
-                # Window standard data
+              # Window standard data
-                study = study, config = config,
+              study = study, config = config,
-                trad = MyTranslate(),
+              trad = MyTranslate(),
-                parent = parent,
+              parent = parent,
-                # Activate undo/redo and copy/paste shortcut
+              # Activate undo/redo and copy/paste shortcut
-                options = ["undo", "copy"]
+              options = ["undo", "copy"]
-            )
+          )
 
-            # Add custom data to hash window computation
+          # Add custom data to hash window computation
-            self._hash_data.append(self._my_data)
+          self._hash_data.append(self._my_data)
 
-            # Setup custom window components
+          # Setup custom window components
-            self.setup_table()
+          self.setup_table()
-            self.setup_connections()
+          self.setup_connections()
 
-        def setup_table(self):
+      def setup_table(self):
-            # Init table(s)...
+          # Init table(s)...
 
-        def setup_connections(self):
+      def setup_connections(self):
-            # Init action connection(s)...
+          # 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
+To define a new plot you can create a class who inherit to
-creator need threee argument:
+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):
+  class MyPlot(PamhyrPlot):
-      def __init__(self, canvas=None, data=None, toolbar=None):
+      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
+A very small part of Pamhyr2 has unit test. This part is limited to the Model.
-in progress*.
+
+#+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:
+This mode add some log and add two action in main window menu: "About
-"About/Debug" open a window with Python Repl in current Python
+> Debug" open a window with Python Repl in current Python
-environement, and "About/Debug SQLite" who open the application
+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]]
 

doc/tools/PamhyrDoc.cls

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

full-requirements.txt

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

packages/debug.bat

@@ -0,0 +1,3 @@
+@echo off
+
+start cmd /c pamhyr.exe debug

packages/debug.sh

@@ -0,0 +1,3 @@
+#! /bin/sh
+
+./pamhyr debug

packages/make-windows-dir.bat

@@ -16,34 +16,35 @@ rem along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 @ECHO ON
 
-mkdir pamhyr\pamhyr\_internal
+mkdir pamhyr\_internal
-xcopy /s /e /y dist\pamhyr pamhyr\pamhyr
+xcopy /s /e /y dist\pamhyr pamhyr
 
 rem Copy data
-mkdir pamhyr\pamhyr\_internal\lang
+mkdir pamhyr\_internal\lang
-mkdir pamhyr\pamhyr\_internal\View\ui\ressources
+mkdir pamhyr\_internal\View\ui\ressources
-mkdir pamhyr\pamhyr\_internal\View\ui\Widgets
+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\ressources\ pamhyr\_internal\View\ui\ressources
-copy /y ..\src\View\ui\Widgets\*.ui pamhyr\pamhyr\_internal\View\ui\Widgets
+copy /y ..\src\View\ui\Widgets\*.ui pamhyr\_internal\View\ui\Widgets
-copy /y ..\src\View\ui\*.ui pamhyr\pamhyr\_internal\View\ui\
+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 ..\VERSION pamhyr\_internal
-copy /y ..\AUTHORS pamhyr\pamhyr\_internal
+copy /y ..\AUTHORS pamhyr\_internal
-copy /y ..\LICENSE pamhyr\pamhyr\_internal
+copy /y ..\LICENSE pamhyr\_internal
-copy /y ..\src\motd.txt pamhyr\pamhyr\_internal
+copy /y ..\src\motd.txt pamhyr\_internal
 
 rem MAGE
-mkdir pamhyr\mage
+mkdir pamhyr\mage8
-copy /y ..\mage-windows\mage.exe pamhyr\mage\
+copy /y ..\mage8-windows\mage.exe pamhyr\mage8\
-copy /y ..\mage-windows\mage_extraire.exe pamhyr\mage\
+copy /y ..\mage8-windows\mage_as7.exe pamhyr\mage8\
-copy /y ..\mage-windows\mailleurTT.exe pamhyr\mage\
+copy /y ..\mage8-windows\mage_extraire.exe pamhyr\mage8\
-copy /y ..\mage-windows\libbief.dll pamhyr\mage\
+copy /y ..\mage8-windows\mailleurTT.exe pamhyr\mage8\
+copy /y ..\mage8-windows\libbief.dll pamhyr\mage8\
 
 rem Copy tests_cases
 mkdir pamhyr\tests_cases

packages/pamhyr.nsi

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

requirements.txt

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

src/Checker/Checker.py

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

src/Checker/Mage.py

@@ -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 \
+            "Check if exists geometry guidelines are correctly defined \
-for each reaches of the study"
+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:]:

src/Checker/Study.py

@@ -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:
+        if not self.basic_check(study):
-            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
 
         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:
+        if not self.basic_check(study):
-            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
 
         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__()

src/Meshing/Mage.py

@@ -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(
+                list(
-                    str,
+                    map(
-                    [
+                        str,
-                        st_file, m_file, step,
+                        [
-                        limites[0], limites[1],
+                            st_file, m_file,
-                        directrices[0], directrices[1],
+                            "mesh", step,
-                        lplan, lm, linear
+                            limites[0], limites[1],
-                    ]
+                            directrices[0], directrices[1],
-                ))
+                            lplan, lm, linear, origin, origin_value
+                        ]
+                    )
+                )
             )
             proc.waitForFinished()
 
-            errors = proc.readAllStandardError()
+            if proc.exitCode() != 0:
-            if len(errors) != 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:
+                return reach
-                self.import_m_file(reach, m_file)
+
+            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()
+        if os.path.exists(m):
-
+            reach.purge()
-        logger.debug(f"meshing: Import geometry from {m}")
+            logger.debug(f"meshing: Import geometry from {m}")
-        reach.import_geometry(m)
+            reach.import_geometry(m)
+        else:
+            logger.error(f"meshing: Meshed geometry file {m} do not exists")

src/Meshing/test_Meshing.py

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

src/Model/AdditionalFile/AddFile.py

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

src/Model/AdditionalFile/AddFileList.py

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

src/Model/BoundaryCondition/BoundaryCondition.py

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

src/Model/Except.py

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

src/Model/Friction/Friction.py

@@ -43,8 +43,8 @@ class Friction(SQLSubModel):
 
         self._name = name
         self._edge = None
-        self._begin_kp = 0.0
+        self._begin_rk = 0.0
-        self._end_kp = 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,
+            begin_rk REAL NOT NULL,
-            end_kp 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,12 @@ 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 +86,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 +108,8 @@ class Friction(SQLSubModel):
             # Create friction
             sec = cls(status=status)
             sec.edge = reach
-            sec.begin_kp = row[2]
+            sec.begin_rk = row[2]
-            sec.end_kp = row[3]
+            sec.end_rk = row[3]
             sec.begin_strickler = bs
             sec.end_strickler = es
 
@@ -124,11 +130,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 +163,10 @@ class Friction(SQLSubModel):
     def edge(self, edge):
         self._edge = edge
         if (edge is not None and
-            self._begin_kp == 0.0 and
+            self._begin_rk == 0.0 and
-                self._end_kp == 0.0):
+                self._end_rk == 0.0):
-            self._begin_kp = self._edge.reach.get_kp_min()
+            self._begin_rk = self._edge.reach.get_rk_min()
-            self._end_kp = self._edge.reach.get_kp_max()
+            self._end_rk = self._edge.reach.get_rk_max()
         self._status.modified()
 
     def has_edge(self):
@@ -176,39 +182,47 @@ class Friction(SQLSubModel):
         return self.has_edge() and self.has_coefficient()
 
     @property
-    def begin_kp(self):
+    def begin_rk(self):
-        return self._begin_kp
+        return self._begin_rk
 
-    @begin_kp.setter
+    @begin_rk.setter
-    def begin_kp(self, begin_kp):
+    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()
+            _min = self._edge.reach.get_rk_min()
-            _max = self._edge.reach.get_kp_max()
+            _max = self._edge.reach.get_rk_max()
 
-            if _min <= begin_kp <= _max:
+            if _min <= begin_rk <= _max:
-                self._begin_kp = begin_kp
+                self._begin_rk = begin_rk
 
         self._status.modified()
 
     @property
-    def end_kp(self):
+    def end_rk(self):
-        return self._end_kp
+        return self._end_rk
 
-    @end_kp.setter
+    @end_rk.setter
-    def end_kp(self, end_kp):
+    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()
+            _min = self._edge.reach.get_rk_min()
-            _max = self._edge.reach.get_kp_max()
+            _max = self._edge.reach.get_rk_max()
 
-            if _min <= end_kp <= _max:
+            if _min <= end_rk <= _max:
-                self._end_kp = end_kp
+                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

src/Model/Friction/FrictionList.py

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

src/Model/Geometry/PointXYZ.py

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

src/Model/Geometry/Profile.py

@@ -19,6 +19,7 @@
 import logging
 
 from tools import timer
+from shapely import geometry
 
 from Model.Geometry.Point import Point
 from Model.Except import NotImplementedMethodeError
@@ -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
+    @rk.setter
-    def kp(self, value: float):
+    def rk(self, value: float):
-        self._kp = float(value)
+        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)

src/Model/Geometry/ProfileXYZ.py

@@ -22,6 +22,7 @@ from typing import List
 from functools import reduce
 
 from tools import timer
+from shapely import geometry
 
 from Model.Tools.PamhyrDB import SQLSubModel
 from Model.Except import ClipboardFormatError
@@ -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):
+    def speed(self, q, z):
-        first_point = self.points[0]
+        area = self.wet_area(z)
 
-        for point in self.points:
+        if area == 0:
-            if not point.is_nan():
+            return 0
-                first_point = point
-                break
 
-        return first_point
+        return q / area
-
-    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))
 
     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)
+                    )

src/Model/Geometry/Reach.py

@@ -16,7 +16,9 @@
 
 # -*- coding: utf-8 -*-
 
+import os
 import logging
+import shapefile
 import numpy as np
 
 from time import time
@@ -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):
+    def get_rk(self):
-        """List of profiles kp
+        """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):
+    def get_rk_min(self):
-        if len(self.get_kp()) > 0:
+        if len(self.get_rk()) > 0:
-            return min(self.get_kp())
+            return min(self.get_rk())
         else:
             return 0.0
 
-    def get_kp_max(self):
+    def get_rk_max(self):
-        if len(self.get_kp()) > 0:
+        if len(self.get_rk()) > 0:
-            return max(self.get_kp())
+            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

src/Model/HydraulicStructures/HydraulicStructures.py

@@ -50,8 +50,8 @@ class HydraulicStructure(SQLSubModel):
             self.id = id
 
         self._name = name
-        self._input_kp = None
+        self._input_rk = None
-        self._output_kp = 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,
+            input_rk REAL NOT NULL,
-            output_kp 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)
+            input_rk = next(it)
-            output_kp = 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.input_rk = input_rk if input_rk != -1 else None
-            hs.output_kp = output_kp if output_kp != -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
+        input_rk = -1
-        if self.input_kp is not None:
+        if self.input_rk is not None:
-            input_kp = self.input_kp
+            input_rk = self.input_rk
 
-        output_kp = -1
+        output_rk = -1
-        if self.output_kp is not None:
+        if self.output_rk is not None:
-            output_kp = self.output_kp
+            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):
+    def input_rk(self):
-        return self._input_kp
+        return self._input_rk
 
-    @input_kp.setter
+    @input_rk.setter
-    def input_kp(self, input_kp):
+    def input_rk(self, input_rk):
-        if input_kp is not None:
+        if input_rk is not None:
-            input_kp = float(input_kp)
+            input_rk = float(input_rk)
 
-        self._input_kp = input_kp
+        self._input_rk = input_rk
         self._status.modified()
 
     @property
-    def output_kp(self):
+    def output_rk(self):
-        return self._output_kp
+        return self._output_rk
 
-    @output_kp.setter
+    @output_rk.setter
-    def output_kp(self, output_kp):
+    def output_rk(self, output_rk):
-        self._output_kp = output_kp
+        self._output_rk = output_rk
         self._status.modified()
 
     @property

src/Model/InitialConditions/InitialConditions.py

@@ -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:
+        if self._rk != 0.0:
-            self._update_from_kp()
+            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,7 +141,7 @@ 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,
@@ -154,8 +161,8 @@ class Data(SQLSubModel):
             val = self._name
         elif key == "comment":
             val = self._comment
-        elif key == "kp":
+        elif key == "rk":
-            val = self._kp
+            val = self._rk
         elif key == "speed":
             val = self._speed
         elif key == "discharge":
@@ -168,7 +175,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 +183,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 +204,9 @@ class Data(SQLSubModel):
             self._name = str(value)
         elif key == "comment":
             self._comment = str(value)
-        elif key == "kp":
+        elif key == "rk":
-            self._kp = float(value)
+            self._rk = float(value)
-            self._update_from_kp()
+            self._update_from_rk()
         elif key == "speed":
             # Not supposed to be modified
             self._speed = float(value)
@@ -266,6 +273,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 +305,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 +351,8 @@ class InitialConditions(SQLSubModel):
             )
         )
 
-    def get_kp(self):
+    def get_rk(self):
-        return self._data_get("kp")
+        return self._data_get("rk")
 
     def get_elevation(self):
         return self._data_get("elevation")
@@ -341,10 +360,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,14 +372,14 @@ 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 = []
 
         profiles = self._reach.reach.profiles.copy()
-        self._sort_by_z_and_kp(profiles)
+        self._sort_by_z_and_rk(profiles)
 
         incline = self._reach.reach.get_incline_median_mean()
         logger.debug(f"incline = {incline}")
@@ -381,13 +400,13 @@ class InitialConditions(SQLSubModel):
                 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
@@ -406,7 +425,7 @@ class InitialConditions(SQLSubModel):
 
     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
 
@@ -427,13 +446,13 @@ class InitialConditions(SQLSubModel):
                 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 +463,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']
         )

src/Model/LateralContribution/LateralContribution.py

@@ -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._begin_rk = 0.0
-        self._end_kp = 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,
+            begin_rk REAL NOT NULL,
-            end_kp 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._begin_rk = row[4]
-            lc._end_kp = row[5]
+            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._begin_rk = self._edge.reach.get_rk_min()
-            self._end_kp = self._edge.reach.get_kp_max()
+            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):
+    def begin_rk(self):
-        return self._begin_kp
+        return self._begin_rk
 
-    @begin_kp.setter
+    @begin_rk.setter
-    def begin_kp(self, begin_kp):
+    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()
+            _min = self._edge.reach.get_rk_min()
-            _max = self._edge.reach.get_kp_max()
+            _max = self._edge.reach.get_rk_max()
 
-            if _min <= begin_kp <= _max:
+            if _min <= begin_rk <= _max:
-                self._begin_kp = begin_kp
+                self._begin_rk = begin_rk
 
         self._status.modified()
 
     @property
-    def end_kp(self):
+    def end_rk(self):
-        return self._end_kp
+        return self._end_rk
 
-    @end_kp.setter
+    @end_rk.setter
-    def end_kp(self, end_kp):
+    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()
+            _min = self._edge.reach.get_rk_min()
-            _max = self._edge.reach.get_kp_max()
+            _max = self._edge.reach.get_rk_max()
 
-            if _min <= end_kp <= _max:
+            if _min <= end_rk <= _max:
-                self._end_kp = end_kp
+                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.begin_rk = self.begin_rk
-        new.end_kp = self.end_kp
+        new.end_rk = self.end_rk
 
         for i, _ in enumerate(self.data):
             new.add(i)

src/Model/Network/Graph.py

@@ -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):
+    def remove_node(self, node):
-        self._nodes = list(
+        self._nodes.remove(node)
-            filter(
+        self._remove_associated_edge(node)
-                lambda n: n.name != node_name,
-                self._nodes
-            )
-        )
-        self._remove_associated_edge(node_name)
         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
+                lambda e: (e.node1 == node or
-                           e.node2.name == node_name),
+                           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 ?
+        # # This edge already exists ?
-        if any(filter(lambda e: (e.node1 == edge.node1 and
+        # if any(filter(lambda e: (e.node1 == edge.node1 and
-                                 e.node2 == edge.node2),
+        #                          e.node2 == edge.node2),
-                      self._edges)):
+        #               self._edges)):
-            return None
+        #     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):
+    def remove_edge(self, edge):
-        self._edges = list(
+        self._edges.remove(edge)
-            filter(
-                lambda e: e.name != edge_name,
-                self._edges
-            )
-        )
         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: (

src/Model/Network/test_network.py

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

src/Model/REPLine/REPLine.py

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

src/Model/REPLine/REPLineList.py

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

src/Model/Results/River/River.py

@@ -35,8 +35,8 @@ class Profile(object):
         return self._profile.name
 
     @property
-    def kp(self):
+    def rk(self):
-        return self._profile.kp
+        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
+            )
+        )

src/Model/River.py

@@ -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,
+            execute, data
-            data
         )
         data["stricklers"] = new._stricklers
 
         # Initial conditions
         new._sediment_layers = SedimentLayerList._db_load(
-            execute,
+            execute, data
-            data
         )
         data["sediment_layers_list"] = new._sediment_layers
 
         # Network
         new._nodes = RiverNode._db_load(
-            execute,
+            execute, data
-            data
         )
         data["nodes"] = new.nodes()
 
         new._edges = RiverReach._db_load(
-            execute,
+            execute, data
-            data
         )
         data["edges"] = new.edges()
 
         # Boundary Condition
         new._boundary_condition = BoundaryConditionList._db_load(
-            execute,
+            execute, data
-            data
         )
         # Lateral Contribution
         new._lateral_contribution = LateralContributionList._db_load(
-            execute,
+            execute, data
-            data
         )
 
         # Initial conditions
         new._initial_conditions = InitialConditionsDict._db_load(
-            execute,
+            execute, data
-            data
         )
 
         # Reservoir
         new._reservoir = ReservoirList._db_load(
-            execute,
+            execute, data
-            data
         )
 
         # Hydraulic Structures
         new._hydraulic_structures = HydraulicStructureList._db_load(
-            execute,
+            execute, data
-            data
         )
 
         # Parameters
         new._parameters = SolverParametersList._db_load(
-            execute,
+            execute, data
-            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

src/Model/Saved.py

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

src/Model/Study.py

@@ -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)
+        if os.path.exists(self.filename) and ".backup" not in self.filename:
-        shutil.copy(self.filename, filename)
+            filename = os.path.join(fdir, "_PAMHYR_", "__old__", fname)
-        self._old_save_id += 1
+            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', " +
+            "INSERT INTO info VALUES ('date', " +
-            "'{self._date.timestamp()}')"
+            f"'{self._date.timestamp()}')"
         )
 
         self.execute(
-            f"INSERT INTO info VALUES ('creation_date', " +
+            "INSERT INTO info VALUES ('creation_date', " +
-            "'{self.creation_time.timestamp()}')"
+            f"'{self.creation_date.timestamp()}')"
         )
         self.execute(
-            f"INSERT INTO info VALUES ('last_save_date', " +
+            "INSERT INTO info VALUES ('last_save_date', " +
-            "'{self.last_save_time.timestamp()}')"
+            f"'{self.last_save_date.timestamp()}')"
         )
 
         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'"

src/Model/Tools/PamhyrDB.py

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

src/Model/Tools/PamhyrDict.py

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

src/Model/Tools/PamhyrList.py

@@ -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):
+    def index(self, el):
-        return self._lst[row]
+        return self._lst.index(el)
 
-    def set(self, row, new):
+    def get(self, index):
-        self._lst[row] = new
+        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):
+    def get(self, lst, index):
-        return self._tabs[lst][row]
+        return self._tabs[lst][index]
 
-    def set(self, lst, row, new):
+    def set(self, lst, index, new):
-        self._tabs[lst][row] = 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],

src/Modules.py

@@ -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: [],
+}

src/Solver/CommandLine.py

@@ -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
+        try:
-        s = self._process.readAll().data().decode()
+            # Read process output and put lines in queue
+            s = self._process.readAll().data().decode('utf-8', "replace")
 
-        if self._output is not None:
+            if self._output is not None:
-            for x in s.split('\n'):
+                for x in s.split(os.linesep):
-                self._output.put(x)
+                    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:

src/Solver/Mage.py

@@ -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=True, version=cls._type),
-            MageNetworkGraphChecker(connectivity=False),
+            MageNetworkGraphChecker(connectivity=False, version=cls._type),
-            MageGeometryGuideLineChecker(),
+            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 = study.river.enable_edges()
-        edges = list(
-            filter(
-                lambda e: e.is_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_lateral_contrib(self, study, repertory, qlog, name="0"):
-    # def _export_LC(self, lateral, repertory, qlog, name="0"):
+        files = []
-    #     files = []
+        lst = study.river.lateral_contribution
 
-    #     if qlog is not None:
+        with mage_file_open(
-    #         qlog.put(f"Export LAT file")
+                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(
+            for tab in ["liquid", "solid", "suspenssion"]:
-    #             os.path.join(repertory, f"{name}.LAT"),
+                for lateral in lst.get_tab(tab):
-    #             "w+"
+                    self._export_LC(study, lateral, f,  qlog)
-    #     ) as f:
-    #         files.append(f"{name}.LAT")
 
-    #         name = f"{lateral.node.id:3}".replace(" ", "x")
+        return files
-    #         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")
 
-    #         for d in lateral.data:
+    def _export_LC(self, study, lateral, f, qlog, name="0"):
-    #             f.write(f"{d[0]:1{name}.3f}{d[1]:10.3f}\n")
+        if lateral.edge is None:
+            return
 
-    #     return files
+        edges = study.river.enable_edges()
+        if lateral.edge not in edges:
+            return
 
-    # @timer
+        eid, _ = next(
-    # def _export_lateral_contrib(self, study, repertory, qlog, name="0"):
+            filter(
-    #     files = []
+                lambda e: e[1] == lateral.edge,
-    #     lst = study.river.lateral_contribution
+                enumerate(edges)
+            )
+        )
 
-    #     for tab in ["liquid", "solid", "suspenssion"]:
+        name = f"{eid+1:>3}"
-    #         for lateral in lst.get_tab(tab):
+        # name = f"Reach_{lateral.edge.id + 1:>3}".replace(" ", "0")
-    #             files = files + self._export_LC(lateral, repertory,  qlog)
+        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 = study.river.enable_edges()
-            edges = list(
-                filter(
-                    lambda e: e.is_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}"
+                    brk = f"{friction.begin_rk:>10.3f}"
-                    ekp = f"{friction.end_kp:>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:
+                self._export_SIN_bhs(study, sin_dict, hs, f)
-                    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"
-                    )
 
         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 = study.river.enable_edges()
-            edges = list(
-                filter(
-                    lambda e: e.is_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)
+        try:
-        files = files + self._export_PAR(study, repertory, qlog, name=name)
+            for func in self.export_func_dict():
-        files = files + self._export_NET(study, repertory, qlog, name=name)
+                files = files + func(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)
 
-        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

src/Solver/RubarBE.py

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

src/Solver/Solvers.py

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

src/View/About/Window.py

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

src/View/AdditionalFiles/Edit/Window.py

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

src/View/AdditionalFiles/List.py

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

src/View/AdditionalFiles/Translate.py

@@ -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"
+        )

src/View/AdditionalFiles/UndoCommand.py

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

src/View/AdditionalFiles/Window.py

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

src/View/BoundaryCondition/Edit/Table.py

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

src/View/BoundaryCondition/Edit/Window.py

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

src/View/BoundaryCondition/Edit/translate.py

@@ -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"),
+            "time": self._dict["time"],
-            "date": _translate("BoundaryCondition", "Date"),
+            "date": self._dict["date"],
-            "discharge": _translate("BoundaryCondition", "Discharge (m³/s)"),
+            "discharge": self._dict["unit_discharge"],
-            "z": _translate("BoundaryCondition", "Z (m)"),
+            "z": self._dict["unit_elevation"],
             "solid": _translate("BoundaryCondition", "Solid (kg/s)"),
         }

src/View/BoundaryCondition/Table.py

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

src/View/BoundaryCondition/Window.py

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

src/View/BoundaryCondition/translate.py

@@ -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"),
+            "ND": self._dict["not_defined"],
-            "PC": _translate("BoundaryCondition", "Ponctual contribution"),
+            "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"),
+            "name": self._dict["name"],
-            "type": _translate("BoundaryCondition", "Type"),
+            "type": self._dict["type"],
             "node": _translate("BoundaryCondition", "Node")
         }

src/View/CheckList/List.py

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

src/View/CheckList/Table.py

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

src/View/CheckList/Translate.py

@@ -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"),
         }

src/View/CheckList/Worker.py

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

src/View/Configure/Translate.py

@@ -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"),
+            "name": self._dict["name"],
-            "type": _translate("Configure", "Type"),
+            "type": self._dict["type"],
-            "description": _translate("Configure", "Description"),
+            "description": self._dict["description"],
         }
 
         # Solvers

src/View/Configure/Window.py

@@ -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.set_line_edit_text("lineEdit_backup_path",
-                                self._config.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(
+            # "pushButton_backup_path": lambda: self.file_dialog(
-                select_file=False,
+            #     select_file=False,
-                callback=lambda f: self.set_line_edit_text(
+            #     callback=lambda f: self.set_line_edit_text(
-                    "lineEdit_backup_path", f[0]
+            #         "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(
+        # self._config.backup_path = self.get_line_edit_text(
-            "lineEdit_backup_path")
+        #     "lineEdit_backup_path")
         self._config.backup_frequence = self.get_time_edit(
-            "timeEdit_backup_frequence")
+            "timeEdit_backup_frequence"
-        self._config.backup_max = self.get_spin_box("spinBox_backup_max")
+        )
+        # 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

src/View/Debug/Window.py

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

src/View/Doc/Window.py

@@ -50,7 +50,7 @@ class DocWindow(PamhyrWindow):
         return os.path.abspath(
             os.path.join(
                 os.path.dirname(__file__),
-                "..", "..", "..", "..", "doc", filename
+                "..", "..", "..", "doc", filename
             )
         )
 

src/View/Frictions/PlotRKZ.py

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

src/View/Frictions/PlotStricklers.py

@@ -41,10 +41,10 @@ class PlotStricklers(PamhyrPlot):
             parent=parent
         )
 
-        self.label_x = self._trad["kp"]
+        self.label_x = self._trad["rk"]
-        self.label_y = self._trad["stricklers"]
+        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
+                        lambda s: (s.begin_rk == rk_min and
-                                   s.end_kp == kp_max),
+                                   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(
+        self.line_rk_elevation[0] = self.canvas.axes.plot(
-            kp, coef_minor,
+            rk, coef_minor,
             color=color, lw=1.
         )
 
-        self.line_kp_elevation[1] = self.canvas.axes.plot(
+        self.line_rk_elevation[1] = self.canvas.axes.plot(
-            kp, coef_medium,
+            rk, coef_medium,
             color=color, lw=1.
         )
 

src/View/Frictions/Table.py

@@ -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":
+        elif self._headers[column] == "begin_rk":
-            return self._lst.get(row).begin_kp
+            return self._lst.get(row).begin_rk
-        elif self._headers[column] == "end_kp":
+        elif self._headers[column] == "end_rk":
-            return self._lst.get(row).end_kp
+            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

src/View/Frictions/UndoCommand.py

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

src/View/Frictions/Window.py

@@ -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):
+    def _propagated_update(self, key=Modules(0)):
-        if key != "geometry":
+        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)
 

src/View/Frictions/translate.py

@@ -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(
+        self._dict["rk"] = self._dict["unit_rk"]
-            "Frictions", "Kp (m)"
+        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"),
+            # "name": self._dict["name"],
-            # "edge": _translate("Frictions", "Reach"),
+            # "edge": self._dict["reach"],
-            "begin_kp": _translate("Frictions", "Begin kp (m)"),
+            "begin_rk": _translate("Frictions", "Start (m)"),
-            "end_kp": _translate("Frictions", "End kp (m)"),
+            "end_rk": _translate("Frictions", "End (m)"),
-            "begin_strickler": _translate("Frictions", "Begin strickler"),
+            "begin_strickler": _translate("Frictions", "Start coefficient"),
-            "end_strickler": _translate("Frictions", "End strickler"),
+            "end_strickler": _translate("Frictions", "End coefficient"),
         }

src/View/Geometry/MeshingDialog.py

@@ -58,6 +58,7 @@ class MeshingDialog(PamhyrDialog):
         self._end_cs = -1
         self._begin_dir = "un"
         self._end_dir = "np"
+        self._origin = self._reach.profile(0)
 
         self._init_default_values_profiles()
         self._init_default_values_guidelines()
@@ -67,17 +68,6 @@ class MeshingDialog(PamhyrDialog):
             self._space_step
         )
 
-        lm_dict = self._trad.get_dict("lm_dict")
-        self.combobox_add_items(
-            "comboBox_lm", list(
-                map(
-                    lambda x: lm_dict[x],
-                    ["1", "2", "3"]
-                )
-            )
-        )
-        self.set_combobox_text("comboBox_lm", self._lm)
-
         if self._linear:
             self.set_radio_button("radioButton_linear", True)
         else:
@@ -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_begin_rk", profiles)
-        self.combobox_add_items("comboBox_end_kp", profiles)
+        self.combobox_add_items("comboBox_end_rk", profiles)
 
-        self.set_combobox_text("comboBox_begin_kp", profiles[0])
+        self.set_combobox_text("comboBox_begin_rk", profiles[0])
-        self.set_combobox_text("comboBox_end_kp", profiles[-1])
+        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
+        bgl = ['un'] + gl + ['np']
-        egl = 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")
+        p1 = self.get_combobox_text("comboBox_begin_rk")
-        p2 = self.get_combobox_text("comboBox_end_kp")
+        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):

src/View/Geometry/PlotAC.py

@@ -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(
+        self.label_x = self._trad["transverse_abscissa"]
-            "Geometry", "Transverse abscissa (m)"
+        self.label_y = self._trad["unit_height"]
-        )
-        self.label_y = _translate("Geometry", "Height (m)")
 
-        self.label_previous_plot_selected = _translate(
+        self.label_previous_plot_selected = self._trad["prev_cs"]
-            "Geometry", "Previous cross-section"
+        self.label_plot_selected = self._trad["cs"]
-        )
+        self.label_next_plot_selected = self._trad["next_cs"]
-        self.label_plot_selected = _translate(
-            "Geometry", "Cross-section"
-        )
-        self.label_next_plot_selected = _translate(
-            "Geometry", "Next cross-section"
-        )
 
         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()

src/View/Geometry/PlotKPZ.py

@@ -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}")

src/View/Geometry/PlotRKZ.py

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

src/View/Geometry/PlotXY.py

@@ -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_x = self._trad["x"]
-        self.label_y = _translate("Geometry", "Y (m)")
+        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(),
+        for xy in zip(self.data.get_x(), self.data.get_y()):
-                            self.data.get_y(),
+            self.line_xy.append(np.column_stack(xy))
-                            kp):
+
-            line = self.canvas.axes.plot(
+        self._colors, self._style = self.color_hightlight()
-                x, y,
+        self.line_xy_collection = collections.LineCollection(
-                color=color_hightlight(kp),
+            self.line_xy,
-                **self.plot_default_kargs
+            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):
+#        TODO comprendre à quoi sert ce bout de code
-            if i < len(self.line_xy):
+#        ========>
-                self.line_xy[i][0].set_data(
+#        for i in range(self.data.number_profiles):
-                    self.data.profile(i).x(),
+#            if i < len(self.line_xy):
-                    self.data.profile(i).y()
+#                self.line_xy[i][0].set_data(
-                )
+#                    self.data.profile(i).x(),
-            else:
+#                    self.data.profile(i).y()
-                self.line_xy.append(
+#                )
-                    self.canvas.axes.plot(
+#            else:
-                        self.data.profile(i).x(),
+#                self.line_xy.append(
-                        self.data.profile(i).y(),
+#                    self.canvas.axes.plot(
-                        color='r',
+#                        self.data.profile(i).x(),
-                        **self.plot_default_kargs
+#                        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
+            self._colors, self._style = self.color_hightlight()
-            before = ind - 1
+            self.line_xy_collection.set_colors(self._colors)
-            after = ind + 1
+            self.line_xy_collection.set_linestyle(self._style)
 
-            self.before_plot_selected.set_visible(False)
+    def update_lr(self):
-            self.plot_selected.set_visible(False)
+        for line in self.line_lr:
-            self.after_plot_selected.set_visible(False)
+            line[0].remove()
 
-            if 0 <= before < self.data.number_profiles:
+        self.draw_lr()
-                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)

src/View/Geometry/Profile/Plot.py

@@ -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.init_axes()
-        self.canvas.axes.grid(
-            color='grey', linestyle='--', linewidth=0.5
-        )
 
         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
+        if (len(x_carto) < 3 or len(y_carto) < 3 or len(x) < 3):
-                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,
+            x, y, color=self.color_plot,
-            markersize=7, marker='+',
+            lw=1.5, markersize=7, marker='+',
-            picker=30
+            picker=10
-        )
-        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
         )
 
+        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(
+    def draw_highligth(self):
-            self.canvas.axes,
+        points, hyd = self.highlight
-            x, y, x_carto, y_carto,
+        for p in self.hl_points:
-            self._table
+            p[0].set_data([], [])
-        )
-        self.canvas.figure.canvas\
-                          .mpl_connect(
-                              'pick_event',
-                              self.onpick_event.onpick
-                          )
 
-        self.onclick_event = OnpickEvent(
+        self.hl_points = []
-            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.canvas.figure.tight_layout()
+        for x, y in points:
-        self.canvas.figure.canvas.draw_idle()
+            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):
+    def update(self):
-        logger.info("TODO: implemente update")
+        self.draw_highligth()
-        self.draw()
+
+        self.update_idle()

src/View/Geometry/Profile/Table.py

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

src/View/Geometry/Profile/Translate.py

@@ -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)"),
+            "x": self._dict["x"],
-            "y": _translate("Geometry", "Y (m)"),
+            "y": self._dict["y"],
-            "z": _translate("Geometry", "Z (m)"),
+            "z": self._dict["z"],
-            "name": _translate("Geometry", "Name"),
+            "name": self._dict["name"],
             "abs": _translate("Geometry", "Traversal abs (m)"),
         }

src/View/Geometry/Profile/UndoCommand.py

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

src/View/Geometry/Profile/Window.py

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

src/View/Geometry/PurgeDialog.py

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

src/View/Geometry/Table.py

@@ -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
+            rk = self._data.profile(index.row()).rk
-            return f"{kp:.4f}"
+            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()