merge

.gitignore

@@ -1,6 +1,7 @@
 ### CUSTOM ###
 
 *.exe
+*.msi
 *.tar.xz
 *.zip
 *.spec
@@ -9,15 +10,33 @@
 
 tmp
 
+*.tar
 *.tar.*
+*.tgz
 *.zip
 
+*.html
+*.pdf
+*.odt
+
+doc/dev/images/auto_*
+doc/dev/documentation.*
+!doc/dev/*.org
+
+doc/dev/images/auto_*
+doc/users/documentation.*
+!doc/users/*.org
+
+TAGS
+
 pamhyrBuild
 wine-pamhyr-build*
 
 _PAMHYR_
 __old__
 
+*-venv
+
 ### END CUSTOM ###
 
 # Created by https://www.toptal.com/developers/gitignore/api/python
@@ -309,3 +328,318 @@ compile_commands.json
 *_qmlcache.qrc
 
 # End of https://www.toptal.com/developers/gitignore/api/qt
+
+# Created by https://www.toptal.com/developers/gitignore/api/latex
+# Edit at https://www.toptal.com/developers/gitignore?templates=latex
+
+### LaTeX ###
+## Core latex/pdflatex auxiliary files:
+*.aux
+*.lof
+*.log
+*.lot
+*.fls
+*.out
+*.toc
+*.fmt
+*.fot
+*.cb
+*.cb2
+.*.lb
+
+## Intermediate documents:
+*.dvi
+*.xdv
+*-converted-to.*
+# these rules might exclude image files for figures etc.
+# *.ps
+# *.eps
+# *.pdf
+
+## Generated if empty string is given at "Please type another file name for output:"
+.pdf
+
+## Bibliography auxiliary files (bibtex/biblatex/biber):
+*.bbl
+*.bcf
+*.blg
+*-blx.aux
+*-blx.bib
+*.run.xml
+
+## Build tool auxiliary files:
+*.fdb_latexmk
+*.synctex
+*.synctex(busy)
+*.synctex.gz
+*.synctex.gz(busy)
+*.pdfsync
+
+## Build tool directories for auxiliary files
+# latexrun
+latex.out/
+
+## Auxiliary and intermediate files from other packages:
+# algorithms
+*.alg
+*.loa
+
+# achemso
+acs-*.bib
+
+# amsthm
+*.thm
+
+# beamer
+*.nav
+*.pre
+*.snm
+*.vrb
+
+# changes
+*.soc
+
+# comment
+*.cut
+
+# cprotect
+*.cpt
+
+# elsarticle (documentclass of Elsevier journals)
+*.spl
+
+# endnotes
+*.ent
+
+# fixme
+*.lox
+
+# feynmf/feynmp
+*.mf
+*.mp
+*.t[1-9]
+*.t[1-9][0-9]
+*.tfm
+
+#(r)(e)ledmac/(r)(e)ledpar
+*.end
+*.?end
+*.[1-9]
+*.[1-9][0-9]
+*.[1-9][0-9][0-9]
+*.[1-9]R
+*.[1-9][0-9]R
+*.[1-9][0-9][0-9]R
+*.eledsec[1-9]
+*.eledsec[1-9]R
+*.eledsec[1-9][0-9]
+*.eledsec[1-9][0-9]R
+*.eledsec[1-9][0-9][0-9]
+*.eledsec[1-9][0-9][0-9]R
+
+# glossaries
+*.acn
+*.acr
+*.glg
+*.glo
+*.gls
+*.glsdefs
+*.lzo
+*.lzs
+*.slg
+*.slo
+*.sls
+
+# uncomment this for glossaries-extra (will ignore makeindex's style files!)
+# *.ist
+
+# gnuplot
+*.gnuplot
+*.table
+
+# gnuplottex
+*-gnuplottex-*
+
+# gregoriotex
+*.gaux
+*.glog
+*.gtex
+
+# htlatex
+*.4ct
+*.4tc
+*.idv
+*.lg
+*.trc
+*.xref
+
+# hyperref
+*.brf
+
+# knitr
+*-concordance.tex
+# TODO Uncomment the next line if you use knitr and want to ignore its generated tikz files
+# *.tikz
+*-tikzDictionary
+
+# listings
+*.lol
+
+# luatexja-ruby
+*.ltjruby
+
+# makeidx
+*.idx
+*.ilg
+*.ind
+
+# minitoc
+*.maf
+*.mlf
+*.mlt
+*.mtc[0-9]*
+*.slf[0-9]*
+*.slt[0-9]*
+*.stc[0-9]*
+
+# minted
+_minted*
+*.pyg
+
+# morewrites
+*.mw
+
+# newpax
+*.newpax
+
+# nomencl
+*.nlg
+*.nlo
+*.nls
+
+# pax
+*.pax
+
+# pdfpcnotes
+*.pdfpc
+
+# sagetex
+*.sagetex.sage
+*.sagetex.py
+*.sagetex.scmd
+
+# scrwfile
+*.wrt
+
+# svg
+svg-inkscape/
+
+# sympy
+*.sout
+*.sympy
+sympy-plots-for-*.tex/
+
+# pdfcomment
+*.upa
+*.upb
+
+# pythontex
+*.pytxcode
+pythontex-files-*/
+
+# tcolorbox
+*.listing
+
+# thmtools
+*.loe
+
+# TikZ & PGF
+*.dpth
+*.md5
+*.auxlock
+
+# titletoc
+*.ptc
+
+# todonotes
+*.tdo
+
+# vhistory
+*.hst
+*.ver
+
+# easy-todo
+*.lod
+
+# xcolor
+*.xcp
+
+# xmpincl
+*.xmpi
+
+# xindy
+*.xdy
+
+# xypic precompiled matrices and outlines
+*.xyc
+*.xyd
+
+# endfloat
+*.ttt
+*.fff
+
+# Latexian
+TSWLatexianTemp*
+
+## Editors:
+# WinEdt
+*.bak
+*.sav
+
+# Texpad
+.texpadtmp
+
+# LyX
+*.lyx~
+
+# Kile
+*.backup
+
+# gummi
+.*.swp
+
+# KBibTeX
+*~[0-9]*
+
+# TeXnicCenter
+*.tps
+
+# auto folder when using emacs and auctex
+./auto/*
+*.el
+
+# expex forward references with \gathertags
+*-tags.tex
+
+# standalone packages
+*.sta
+
+# Makeindex log files
+*.lpz
+
+# xwatermark package
+*.xwm
+
+# REVTeX puts footnotes in the bibliography by default, unless the nofootinbib
+# option is specified. Footnotes are the stored in a file with suffix Notes.bib.
+# Uncomment the next line to have this generated file ignored.
+#*Notes.bib
+
+### LaTeX Patch ###
+# LIPIcs / OASIcs
+*.vtc
+
+# glossaries
+*.glstex
+
+# End of https://www.toptal.com/developers/gitignore/api/latex

.gitlab-ci.yml

@@ -16,8 +16,9 @@
 
 stages:
   - downloads
-  - build
+  - configure
   - test
+  - build
   - package
   - release
 
@@ -32,7 +33,7 @@ dl-mage-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/Test6/downloads/packages/mage_linux.tgz
+    - curl -L -o mage.tgz https://gitlab.irstea.fr/jean-baptiste.faure/mage/-/releases/v8.3.0/downloads/packages/mage_linux.tgz
     - mkdir -p mage-linux
     - cd mage-linux
     - tar xvf ../mage.tgz
@@ -49,7 +50,7 @@ dl-mage-windows:
   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/Test6/downloads/packages/mage_windows.tgz
+    - curl -L -o mage.tgz https://gitlab.irstea.fr/jean-baptiste.faure/mage/-/releases/v8.3.0/downloads/packages/mage_windows.tgz
     - mkdir -p mage-windows
     - cd mage-windows
     - tar xvf ../mage.tgz
@@ -59,12 +60,12 @@ dl-mage-windows:
       - mage-windows/mage_extraire.exe
       - mage-windows/mailleurPF.exe
 
-#########
+#############
-# BUILD #
+# CONFIGURE #
-#########
+#############
 
 set-version:
-  stage: build
+  stage: configure
   tags:
     - linux
   script:
@@ -75,7 +76,7 @@ set-version:
       - VERSION
 
 build-lang:
-  stage: build
+  stage: configure
   tags:
     - linux
   script:
@@ -85,6 +86,49 @@ build-lang:
     paths:
       - src/lang/*.qm
 
+#########
+# TESTS #
+#########
+
+unittest:
+  stage: test
+  tags:
+    - linux
+  needs:
+    - job: set-version
+      artifacts: true
+  script:
+    - python3 -m venv venv
+    - . venv/bin/activate
+    - pip3 install -U pip
+    - pip3 install -r ./full-requirements.txt
+    - pip3 install -U -r ./full-requirements.txt
+    - cd src
+    - python3 -m unittest discover -t .
+
+test-pep8:
+  stage: test
+  tags:
+    - linux
+  needs:
+    - job: set-version
+      artifacts: true
+    - job: unittest
+  script:
+    # Setup virtual env
+    - python3 -m venv venv
+    - . venv/bin/activate
+    - pip3 install -U pip
+    - pip3 install -r ./requirements.txt
+    - pip3 install -U -r ./requirements.txt
+    - pip3 install pycodestyle
+    - pycodestyle --exclude="*_to_*.py" ./src
+  allow_failure: true
+
+#########
+# BUILD #
+#########
+
 build-users-doc:
   stage: build
   tags:
@@ -98,6 +142,9 @@ build-users-doc:
   artifacts:
     paths:
       - doc/users/documentation.pdf
+      - doc/users/documentation.html
+      - doc/users/images/
+  allow_failure: true
 
 build-developers-doc:
   stage: build
@@ -109,9 +156,26 @@ build-developers-doc:
   script:
     - cd ./doc/dev/
     - ./build.sh
+    # Create html documentation
+    - cd ../../src
+    - python3 -m venv doc-venv
+    - . doc-venv/bin/activate
+    - pip3 install -U pip
+    - pip3 install -r ../full-requirements.txt
+    - pip3 install -U -r ../full-requirements.txt
+    - pip3 install pdoc3
+    - pdoc --html .
+    # Create archive
+    - tar cf html.tar ./html
+    - cd ../doc/dev
+    - mv ../../src/html.tar ./
   artifacts:
     paths:
       - doc/dev/documentation.pdf
+      - doc/dev/documentation.html
+      - doc/dev/html.tar
+      - doc/dev/images/
+  allow_failure: true
 
 build-linux:
   stage: build
@@ -136,39 +200,50 @@ build-linux:
     # Setup virtual env
     - python3 -m venv linux-venv
     - . linux-venv/bin/activate
+    - pip3 install -U pip
     - pip3 install -r ../requirements.txt
+    - pip3 install -U -r ../requirements.txt
     # Run Pyinstaller
     - pyinstaller -y --paths linux-venv/lib/python3.8/site-packages ../src/pamhyr.py
     # Create directory
     - mkdir -p pamhyr
     - mkdir -p pamhyr/pamhyr
+    - mkdir -p pamhyr/pamhyr/_internal
     # Copy Pamhyr info
-    - cp -v ../VERSION pamhyr/pamhyr/
+    - cp -v ../VERSION pamhyr/pamhyr/_internal/
-    - cp -v ../AUTHORS pamhyr/pamhyr/
+    - cp -v ../AUTHORS pamhyr/pamhyr/_internal/
-    - cp -v ../LICENSE pamhyr/pamhyr/
+    - cp -v ../LICENSE pamhyr/pamhyr/_internal/
+    - cp -v ../src/motd.txt pamhyr/pamhyr/_internal/
     # Copy mage
     - mkdir -p pamhyr/mage
     - cp -v ../mage-linux/* pamhyr/mage/
     # Copy Pamhyr
     - cp -r dist/pamhyr pamhyr/
     # Copy Pamhyr resources
-    - mkdir -p pamhyr/pamhyr/View
+    - mkdir -p pamhyr/pamhyr/_internal/View
-    - mkdir -p pamhyr/pamhyr/View/ui
+    - mkdir -p pamhyr/pamhyr/_internal/View/ui
-    - mkdir -p pamhyr/pamhyr/View/ui/Widgets
+    - mkdir -p pamhyr/pamhyr/_internal/View/ui/Widgets
-    - cp -r ../src/View/ui/*.ui pamhyr/pamhyr/View/ui/
+    - cp -r ../src/View/ui/*.ui pamhyr/pamhyr/_internal/View/ui/
-    - cp -r ../src/View/ui/ressources/ pamhyr/pamhyr/View/ui
+    - cp -r ../src/View/ui/ressources/ pamhyr/pamhyr/_internal/View/ui
-    - cp -r ../src/View/ui/Widgets/*.ui pamhyr/pamhyr/View/ui/Widgets
+    - cp -r ../src/View/ui/Widgets/*.ui pamhyr/pamhyr/_internal/View/ui/Widgets
     # Copy lang
-    - mkdir -p pamhyr/pamhyr/lang
+    - mkdir -p pamhyr/pamhyr/_internal/lang
-    - cp -r ../src/lang/*.qm pamhyr/pamhyr/lang
+    - cp -r ../src/lang/*.qm pamhyr/pamhyr/_internal/lang
     # Copy tests cases
     - mkdir -p pamhyr/tests_cases/
     - mkdir -p pamhyr/tests_cases/Saar
     - cp ../tests_cases/Saar/Saar.pamhyr pamhyr/tests_cases/Saar/
     # Copy documentations
     - mkdir -p pamhyr/doc/
+    - mkdir -p pamhyr/doc/images/
+    - mkdir -p pamhyr/doc/html/
     - cp ../doc/users/documentation.pdf pamhyr/doc/Pamhyr2-users.pdf
+    - cp ../doc/users/documentation.html pamhyr/doc/Pamhyr2-users.html
     - cp ../doc/dev/documentation.pdf pamhyr/doc/Pamhyr2-dev.pdf
+    - cp ../doc/dev/documentation.html pamhyr/doc/Pamhyr2-dev.html
+    #- cp ../doc/users/images/* pamhyr/doc/images
+    - cp ../doc/dev/images/* pamhyr/doc/images
+    - cp ../doc/images/* pamhyr/doc/images
     # Create running script
     - echo "#!/bin/sh" > pamhyr/Pamhyr2
     - echo "./pamhyr/pamhyr $@" >> pamhyr/Pamhyr2
@@ -199,6 +274,7 @@ build-windows:
     - cd windows
     # Setup env
     - python -m pip install -r ..\requirements.txt
+    - python -m pip install -U -r ..\requirements.txt
     # Run Pyinstaller
     - pyinstaller -y ..\src\pamhyr.py
     # Create directory
@@ -210,36 +286,6 @@ build-windows:
     paths:
       - windows/pamhyr
 
-#########
-# TESTS #
-#########
-
-# test-windows:
-#   stage: test
-#   tags:
-#     - wine
-#   needs:
-#     - job: set-version
-#       artifacts: true
-#     - job: build-windows
-#       artifacts: true
-#   script:
-#     - cd windows\pamhyr
-#     - pamhyr\pamhyr.exe hello
-
-# test-linux:
-#   stage: test
-#   tags:
-#     - linux
-#   needs:
-#     - job: set-version
-#       artifacts: true
-#     - job: build-linux
-#       artifacts: true
-#   script:
-#     - cd linux/pamhyr
-#     - ./Pamhyr2 hello
-
 ############
 # PACKAGES #
 ############

doc/dev/build.sh

@@ -1,10 +1,18 @@
 #! /bin/sh
 
-# Build the PDF
+echo " PDF  documentation.org"
-
+emacs -nw --batch                                       \
-emacs -Q -q -nw --batch                                 \
       --eval "(require 'org)"                           \
       --eval "(require 'ox-latex)"                      \
       --eval "(load-file \"../tools/setup.el\")"        \
       --file ./documentation.org                        \
       -f org-latex-export-to-pdf
+
+echo " HTML documentation.org"
+emacs -nw --batch                                       \
+      --eval "(require 'org)"                           \
+      --eval "(require 'ox-latex)"                      \
+      --eval "(require 'ox-html)"                       \
+      --eval "(load-file \"../tools/setup.el\")"        \
+      --file ./documentation.org                        \
+      -f org-html-export-to-html

doc/dev/documentation.org

@@ -73,7 +73,7 @@ https://doc.qt.io/qt-5/model-view-programming.html (last access
 [fn:org] The org-mode website: https://orgmode.org/ (last access
 2023-09-15)
 
-* TODO Architecture
+* Architecture
 
 Pamhyr2's architecture is based on Qt Model/View, see Figure
 [[graph-architecture]]. It is made up of several different components: the
@@ -97,35 +97,68 @@ simulation results to model data.
 #+name: graph-architecture
 #+header: :results drawer
 #+header: :exports results
-#+header: :post attr_wrap(width="9cm", data=*this*, name="graph-architecture", caption="Pamhyr2 Model/View architecture scheme (inspired by Qt Model/View architecture [[https://doc.qt.io/qt-5/model-view-programming.html]])", float="t")
+#+header: :post attr_wrap(width="12cm", data=*this*, name="graph-architecture", caption="Pamhyr2 Model/View architecture scheme (inspired by Qt Model/View architecture [[https://doc.qt.io/qt-5/model-view-programming.html]])", float="t")
-#+begin_src dot :file "images/graph-architecture.png" :cache no
+#+begin_src dot :file "images/auto_graph-architecture.png" :cache no
   digraph {
         bgcolor="transparent";
         node[colorscheme=set19,shape=box,style="filled",fillcolor=white];
+        edge[colorscheme=set19,color=0];
+
+        root[style=invis];
+
+        subgraph cluster0 {
+            label="File System"
+            style=dashed;
 
             save[label="Pamhyr save",fillcolor="9",shape=note];
+            sbin[label="Solver binary",fillcolor="9",shape=note];
+            configfile[label="Pamhyr configuration file",fillcolor="9",shape=note];
+        }
+
+        user[label="User",shape=ellipse];
+
+        subgraph cluster1 {
+            label="Pamhyr2";
+
+            config[label="Configuration",fillcolor="5"];
             model[label="Model",fillcolor="2"];
             view[label="View",fillcolor="1"];
             delegate[label="Delegate",fillcolor="3"];
             action[label="Action",fillcolor="3"];
             solver[label="Solver",fillcolor="6"];
             undocommand[label="Command",fillcolor="4"];
-        user[label="User",shape=ellipse];
+        }
 
-        model -> save[label="Save"];
+        root -> model[style=invis];
-        save -> model[label="Load"];
+        root -> config[style=invis];
+
+        model -> save[dir=both,label="Save/Load"];
+        config -> configfile[dir=both,label="Save/Load"];
+
+        undocommand -> solver[style=invis];
+        action -> solver[style=invis];
+        delegate -> solver[style=invis];
 
         model -> view[label="Rendering"];
         view -> delegate[label="Rendering"];
         delegate -> undocommand[label="Create"];
-        action -> undocommand[label="Create"];
+        action -> undocommand[label="Create/use"];
         action -> solver[label="Run"];
-        solver -> model[label="Add results"];
+        solver -> model[dir=both,label="Export/Results",labelangle=0,labelfloat=true,constraint=true];
+        solver -> sbin[dir=both,label="Execute/Results"];
         undocommand -> model[label="Modify"];
 
         view -> user[label="Vizualize"];
         user -> delegate[label="Modify"];
-        user -> action[label="Activate"];
+        user -> action[label="Triggere"];
+
+        config -> solver[label="Create",style=dashed,labelfloat=true,constraint=true];
+        //model -> config[style=invis];
+        config -> model[style=invis];
+        delegate -> action[style=invis];
+        save -> configfile[style=invis];
+        root -> solver[style=invis];
+        user -> solver[style=invis];
   }
 #+end_src
 
@@ -134,50 +167,85 @@ All the model source code are in the directory {{{file(src/Model)}}}
 delegate and command are in {{{file(src/View)}}} (see section [[View]]). Solvers classes are
 in {{{file(src/Solver)}}} (see section [[Solver]]).
 
+The following sub section show examples of main {{{pamhyr}}} internal
+class for view componants, but this documentation is not exhaustive,
+be free to watch existing code for more details and examples. In,
+addition some features are not factorise and must be implemented from
+scratch (directly with Qt for example).
+
 [fn:qt-mv] The Qt Model/View documentation web page:
 https://doc.qt.io/qt-5/model-view-programming.html
 
-** TODO Model
+** Model
 
-- Model de donnée Python
+The model is a set of Python classes. In Pamhyr2, this classes must
-- Correspond à une sauvegarde SQL
+respect some constraint. Each model class must inherits
+=Model.Tools.SQLSubModel= abstract class, except the =Model.Study=
+class who inherits =Model.Tools.SQLModel= (see [[SQL]]).
+
+The model entry point is the Study class. It contains infomation about
+the study: their name, description, time system, and so on. Their
+contains a River object too. This river object inherits the network
+graph and contains a list of =RiverNode= and a list of =RiverReach=
+(an edge who contains a source node, and destination node).
+=RiverReach= contrains geometry, so, the river network (node and edge)
+associated with the geometry forms the basis of the model, and the
+other components are linked to one of these basic components.
 
 #+name: graph-model
 #+header: :results drawer
 #+header: :exports results
-#+header: :post attr_wrap(width="16cm", data=*this*, name="graph-model", caption="Pamhyr2 model class dependencies", float="t")
+#+header: :post attr_wrap(width="16cm", data=*this*, name="graph-model", caption="Pamhyr2 model class dependencies (A -> B means A can contain references to B)", float="t")
-#+begin_src dot :file "images/graph-model.png" :cache no
+#+begin_src dot :file "images/auto_graph-model.png" :cache no
   digraph {
       bgcolor="transparent";
       node[colorscheme=set19,shape=box,style="filled",fillcolor="2"];
 
+      //subgraph cluster0 {
+      //    style=dashed;
           study[label="Study"];
           river[label="River"];
 
           subgraph cluster00 {
+              style=solid;
               label="Network"
               rnode[label="RiverNode"];
               redge[label="RiverReach"];
           }
 
+          subgraph cluster06 {
+              style=solid;
+              label="Greometry"
+              georeach[label="Reach"];
+              geocrosssection[label="Cross-section"];
+              geopoint[label="Point"];
+          }
+      //}
+
+      //subgraph cluster1 {
+      //    style=dashed;
           frictionlist[label="FrictionList"];
 
           subgraph cluster01 {
+              style=solid;
               label="Stricklers";
               stricklers[label="Stricklers"];
               stricklerslist[label="StricklersList"];
           }
           subgraph cluster02 {
+              style=solid;
               label="BoundaryCondition";
               boundaryconditionlist[label="BoundaryConditionList"];
               boundarycondition[label="BoundaryCondition"];
           }
           subgraph cluster03 {
+              style=solid;
               label="LateralContribution";
               lateralcontributionlist[label="LateralContributionList"];
               lateralcontribution[label="LateralContribution"];
           }
           subgraph cluster04 {
+              style=solid;
               label="InitialConditions";
               initialconditionsdict[label="InitialConditionsDict"];
               initialconditions[label="InitialConditions"];
@@ -186,20 +254,16 @@ https://doc.qt.io/qt-5/model-view-programming.html
           solverparameterslist[label="SolverParametersList"];
 
           subgraph cluster05 {
+              style=solid;
               label="Sediment";
               sedimentlayerlist[label="SedimentLayerList"];
               sedimentlayer[label="SedimentLayer"];
               layer[label="Layer"];
           }
+      //}
 
-        subgraph cluster06 {
+      subgraph cluster2 {
-            label="Greometry"
+          style=dashed;
-            georeach[label="Reach"];
-            geocrosssection[label="Cross-section"];
-            geopoint[label="Point"];
-        }
-
-        subgraph cluster07 {
           label="Results"
           results[label="Results"]
           rriver[label="River"];
@@ -223,41 +287,564 @@ https://doc.qt.io/qt-5/model-view-programming.html
       geocrosssection -> sedimentlayer;
       geopoint -> sedimentlayer;
 
-        results -> study[style="dashed"];
+      results -> study;
       results -> rriver;
-        rriver -> river[style="dashed"];
+      rriver -> river;
       rriver -> rreach;
-        rreach -> georeach[style="dashed"];
+      rreach -> georeach;
       rreach -> rcrosssection;
-        rcrosssection -> geocrosssection[style="dashed"];
+      rcrosssection -> geocrosssection;
+
+      // river -> boundaryconditionlist -> boundarycondition -> results[style=invis];
+      // river -> lateralcontributionlist -> lateralcontribution -> results[style=invis];
+      // river -> initialconditionsdict -> initialconditions -> results[style=invis];
+      // initialconditions -> results[style=invis];
+      // river -> stricklerslist -> stricklers -> results[style=invis];
+      // river -> solverparameterslist -> results[style=invis];
+      // river -> sedimentlayerlist -> sedimentlayer -> layer -> results[style=invis];
+
+      geopoint -> boundaryconditionlist[style=invis];
+      geopoint -> lateralcontributionlist[style=invis];
+      geopoint -> initialconditionsdict[style=invis];
+      geopoint -> initialconditions[style=invis];
+      geopoint -> stricklerslist[style=invis];
+      geopoint -> solverparameterslist[style=invis];
+      geopoint -> sedimentlayerlist[style=invis];
   }
 #+end_src
 
-*** TODO SQL study file
+*** SQL
-*** TODO List class
+
-*** TODO Dict class
+The model must be export to a database file to create a study save
-** TODO View
+file. This file use SQLite3[fn:sqlite] format and the extention
-*** TODO UI file
+=.pamhyr=. So, each model componante must be register into this study
-*** TODO Translate
+file. To create, update, set and get information into SQLite database
-*** TODO Window
+we use SQL command. The database use version number and some
-*** TODO UndoCommand
+modification could be perform to update database. For each model
-*** TODO Table
+componante, correspond one or more SQL table to store information. To
-*** TODO Plot
+normalize the interaction with database we made two classes, SQLModel
-*** TODO Mainwindow
+and SQLSubModel. The Study class use SQLModel because is the top of
-** TODO Solver
+the model hierachy. The rest of model class inherits to SQLSubModel.
+
+A class who inherits SQLSubModel, must implement some methods:
+- =_sql_create=: Class method to create the database scheme
+- =_sql_update=: Class method to update the database scheme if necessary
+- =_sql_load=: Class method to load data from DB
+- =_sql_save=: Method to save current object into DB
+
+Class method take in arguments: The class (=cls=), a function to
+execute SQL command into the database (=execute=). In addition, the
+update method take the previous version of database, load method take
+an optional arguments =data= if additional infomation ar needed, and
+who can contains whatever you want. The method save take in arguments
+the current object (=self=), a function to execute SQL command into
+the database (=execute=), and optional data (=data=).
+
+The class who inherits SQLSubModel can also define an class attribute
+=_sub_classes= to set a formal class dependencies into database. This
+attribute is use at database creation to create all table, and at
+update to update all the database table. Let see examples of
+SQLSubModel usage for two classes Foo and Bar with Foo contains list
+of Bar (Listing [[sql-bar]] and [[sql-foo]]).
+
+#+NAME: sql-bar
+#+CAPTION: Exemple of class Bar inherits SQLSubModel.
+#+begin_src python :python python3 :results output :noweb yes
+  from Model.Tools.PamhyrDB import SQLSubModel
+
+  class Bar(SQLSubModel):
+      _id_cnt = 0
+      def __init__(self, id = -1, x = 0, y = 0):
+          self._x = x
+          self._y = y
+          if id == -1:
+              self.id = Bar._id_cnt + 1
+          else:
+              self.id = id
+          Bar._id_cnt = max(id, Bar._id_cnt+1)
+
+      @classmethod
+      def _sql_create(cls, execute):
+          execute("""
+            CREATE TABLE bar (
+              id INTEGER NOT NULL PRIMARY KEY,
+              x INTEGER NOT NULL,
+              foo_id INTEGER NOT NULL,
+              FOREIGN KEY(foo_id) REFERENCES foo(id),
+            )""")
+          return True
+
+      @classmethod
+      def _sql_update(cls, execute, version):
+          # If version is lesser than 0.0.2, add column to bar table
+          major, minor, release = version.strip().split(".")
+          if major == minor == "0":
+              if int(release) < 2:
+                  execute("ALTER TABLE bar ADD COLUMN y INTEGER")
+          return True
+
+      @classmethod
+      def _sql_load(cls, execute, data = None):
+          new = []
+          table = execute(
+              f"SELECT id, x, y FROM bar WHERE foo_id = {data['id']}"
+          )
+          for row in table:
+              bar = cls(
+                  id = row[0], x = row[1], y = row[2],
+              )
+              new.append(bar)
+          return new
+
+      def _sql_save(self, execute, data = None):
+          execute("INSERT INTO bar (id,x,y,foo_id) VALUES " +
+                  f"({self.id}, {self._x}, {self._y}, {data['id']})")
+#+end_src
+
+#+NAME: sql-foo
+#+CAPTION: Exemple of class Foo inherits SQLSubModel and contains a list of Bar object (Listing [[sql-bar]]).
+#+begin_src python :python python3 :results output :noweb yes
+  class Foo(SQLSubModel):
+      _id_cnt = 0
+      _sub_classes = [Bar]
+
+      def __init__(self, id = -1, name = ""):
+          self._name = name
+          self._bar = []
+          # ...
+
+      @classmethod
+      def _sql_create(cls, execute):
+          execute("""
+            CREATE TABLE foo (
+              id INTEGER NOT NULL PRIMARY KEY,
+              name TEXT NOT NULL,
+            )
+          """)
+          return cls._create_submodel(execute)
+
+      @classmethod
+      def _sql_update(cls, excute, version):
+          return cls._update_submodel(execute, version)
+
+      @classmethod
+      def _sql_load(cls, execute, data = None):
+          new = []
+          table = execute(
+              "SELECT id, name FROM foo"
+          )
+          for row in table:
+              foo = cls(
+                  id = row[0],
+                  name = row[1],
+              )
+              data = {
+                  "id": row[0],     # Current Foo ID
+              }
+              foo._bar = Bar._sql_load(execute, data=data)
+              new.append(foo)
+          return new
+
+      def _sql_save(self, execute, data = None):
+          execute(f"DELETE FROM foo WHERE id = {self.id}")
+          execute(f"DELETE FROM bar WHERE foo_id = {self.id}")
+          # Save new data
+          execute(f"INSERT INTO bar (id,name) VALUES ({self.id}, {self._name})")
+          data = {"id": self.id}
+          for bar in self._bar:
+              bar._sql_save(execute, data=data)
+#+end_src
+
+[fn:sqlite] The SQLite web site: https://www.sqlite.org/index.html
+(last access 2023-09-20)
+
+*** List class
+
+A abstract class PamhyrModelList is available and provide some of
+basic methods for object list in Model. This abstract class implement
+some classic action in View like: insert new object, delete object,
+sort, move object up, move object down, and so on. An variant exists
+for multiple list with same type of object, each sublist is called
+tab, because in View, this kind of list si prensented in different
+table PamhyrModelListWithTab.
+
+*** Dict class
+
+A abstract class PamhyrModelDict is available and provide some of
+basic methods for object dictionary in Model. This class is like
+PamhyrModelList but use a dictionary instead of list.
+
+** View
+
+Pamhyr2 use Qt as graphical user interface library with the
+application "Qt designer" for windows or widget creation (see [[UI file]])
+and "Qt linguist" for interface translate (see [[Translate]]). In
+addition, we use matplotlib as ploting library (see [[Plot]]).
+
+Typically, each model componant have an associated window in
+application to add, delete or edit this componant. At top level of
+View directory we found the =MainWindow.py= file and some
+sub-directories. A view sub-directory contains: A =Window.py= file, a
+=Table.py= file with table model definition if nessessary, one or more
+=Plot*.py= file with plot class definition, a =translate.py= file with
+componant translate, and possible other files or sub-directories.
+
+*** UI file
+
+We define as possible all Pamhyr2 windows and custom widgets with "Qt
+designer". This application generate UI file who describes interface
+organisation with table, layout, button, etc. This method is faster
+than hand made windows and widget creation, and saves us some purely
+descriptive code. The UI files are saved into =src/View/ui= for
+window, and =/src/View/ui/Widgets= for custom widget.
+
+*** Translate
+
+#+NAME: pamhyr-trad
+#+CAPTION: Example of =PamhyrTranslate= class implementation with a global traduction for /FooBar/ and a additional dictionary =table_headers=
+#+begin_src python :python python3 :results output :noweb yes
+  from PyQt5.QtCore import QCoreApplication
+  from View.Tools.PamhyrTranslate import PamhyrTranslate
+  _translate = QCoreApplication.translate
+
+  class MyTranslate(PamhyrTranslate):
+      def __init__(self):
+          super(MyTranslate, self).__init__()
+
+          # Add traduction to global dictionary
+          self._dict["My"] = _translate("My", "FooBar")
+          # Add an additional translate dictionary
+          self._sub_dict["table_headers"] = {
+              "foo": _translate("My", "Foo"),
+              "bar": _translate("My", "Bar"),
+              "baz": _translate("My", "Baz"),
+          }
+#+end_src
+
+*** Window
+
+The abstract class PamhyrWindow and PamhyrDialog are used for most of
+Pamhyr2 window. These class allow to create an window for Pamhyr2 GUI
+and implemente some useful methods. The super class method difine some
+generic value from optional parameters, for examples:
+- =self._study=: The study giving in constructor parameters =study=
+  (typically a =Model.Study= class object)
+- =self._config=: The configuration giving in constructor parameters
+  =config= (typically a =Config= class object)
+- =self._trad=: The traductor dictionary giving in constructor
+  parameters =trad= (typically a =Model.Tools.PamhyrTranslate= class
+  object)
+
+#+NAME: window
+#+CAPTION: Example of Pamhyr2 window
+#+begin_src python :python python3 :results output :noweb yes
+    from View.Tools.PamhyrWindow import PamhyrWindow
+    from View.My.Translate import MyTranslate
+    from View.My.Table import MyTableModel
+
+    class MyWindow(PamhyrWindow):
+        _pamhyr_ui = "MyUI"
+        _pamhyr_name = "My window"
+
+        def __init__(self, my_data=None,
+                     study=None, config=None,
+                     parent=None):
+            self._my_data = my_data
+
+            super(MyWindow, self).__init__(
+                # Window title
+                title = self._pamhyr_name + " - " + study.name,
+                # Window standard data
+                study = study, config = config,
+                trad = MyTranslate(),
+                parent = parent,
+                # Activate undo/redo and copy/paste shortcut
+                options = ["undo", "copy"]
+            )
+
+            # Add custom data to hash window computation
+            self._hash_data.append(self._my_data)
+
+            # Setup custom window components
+            self.setup_table()
+            self.setup_connections()
+
+        def setup_table(self):
+            # Init table(s)...
+
+        def setup_connections(self):
+            # Init action connection(s)...
+
+        # ...
+#+end_src
+
+Typically we called method =setup_*=, the method to initialize some
+window componants or connections.
+
+*** Table
+
+An abstract class PamhyrTableModel is available to define a simple
+QAbstractTableModel shortly. In simple cases, there are only =data=
+and =setData= methode to implement, but the constructor needs more
+information than a classic QAbstractTableModel class.
+
+#+NAME: table-src
+#+CAPTION: Definition of a table model from =PamhyrTableModel= in a file =View/My/Table.py=.
+#+begin_src python :python python3 :results output :noweb yes
+  from View.Tools.PamhyrTable import PamhyrTableModel
+
+  class MyTableModel(PamhyrTableModel):
+      def data(self, index, role):
+          # Retrun data at INDEX...
+
+      @pyqtSlot()
+      def setData(self, index, value, role=Qt.EditRole):
+          # Set VALUE at INDEX...
+#+end_src
+
+#+CAPTION: Using the table model defined in Listing [[table-src]] in window funtion =setup_table= defined Listing [[window]].
+#+begin_src python :python python3 :results output :noweb yes
+  # Table model creation (Window.py: setup_table)
+  table_headers = self._trad.get_dict("table_headers")
+  self._model = MyTableModel(
+      table_view = table,         # The table view object
+      table_headers = table_headers, # The table column headers dict
+                                     # (with traduction)
+      editable_headers = ["foo", "bar"], # List of editable column name
+      delegates = {
+          "bar": self.my_delegate, # Custom delegate for column 'bar'
+      },
+      data = self._my_lst,         # The data
+      undo = self._undo_stack,     # The window undo command stack
+  )
+#+end_src
+
+*** UndoCommand
+
+All model modification must be done by an QUndoCommand, this command
+allow to undo and redo an action. This a Qt class wi can inherit to
+define custom undo command (see example Listing [[undo-cmd]])
+
+#+NAME: undo-cmd
+#+CAPTION: Example of custom UndoCommand, this command allow to add a node to graph in river network window (method redo), and delete it to graph with undo method
+#+begin_src python :python python3 :results output :noweb yes
+class AddNodeCommand(QUndoCommand):
+    def __init__(self, graph, node):
+        QUndoCommand.__init__(self)
+
+        self._graph = graph
+        self._node = node
+
+    def undo(self):
+        self._graph.remove_node(self._node.name)
+
+    def redo(self):
+        self._graph.insert_node(self._node)
+#+end_src
+
+All undo command must be push into a =QUndoStack= (see Listing
+[[undo-cmd-push]]) to perform the action and allow user undo and redo this
+action. In PamhyrWindow (and PamhyrDialog) the undo stack is
+automatically create if the option ="undo"= is activate at window
+creation, this stack is accessible at =self._undo_stack=.
+
+#+NAME: undo-cmd-push
+#+CAPTION: Example of UndoCommand push into an undo stack.
+#+begin_src python :python python3 :results output :noweb yes
+  self._undo_stack.push(
+      AddNodeCommand(
+          self._graph,
+          node
+      )
+  )
+#+end_src
+
+*** Plot
+
+To define a new plot you can create a class who inherit to APlot. The
+creator need threee argument:
+ - A =canvas= of type =MplCanvas=
+ - A =data= used in =draw= and =update= to create and update the plot
+ - A optional =toolbar= of type =PamhyrToolbar=
+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.
+
+#+begin_src python :python python3 :results output :noweb yes
+  from View.Tools.PamhyrPlot import PamhyrPlot
+
+  class MyPlot(APlot):
+      def __init__(self, canvas=None, data=None, toolbar=None):
+          super(MyPlot, self).__init__(
+              canvas=canvas,
+              data=data,
+              toolbar=toolbar
+          )
+
+      def draw(self):
+          # Draw function code...
+
+      def update(self, ind = None):
+          # Update function code...
+#+end_src
+
+** Solver
+
+The Pamhyr2 architecture allow to define multiple solver. A solver is
+define by a:
+ - type
+ - name
+ - description,
+ - path
+ - command line pattern
+ - (optional) input formater path
+ - (optional) input formater command line
+ - (optional) output formater path
+ - (optional) output formater command line
+
+Let see Figure [[graph-multi-solver]], the application can implement
+different solver type, this solver type implement the code for export
+study to solver input format, and read the solver output to study
+results. There exists a generic solver with a generic input and output
+format, the type could be use to use a solver not implemented in
+Pamhyr2, but this solver must can read/write input and output generic
+format or use external script. There is possible to define different
+solver with the same type, for example two differents version of the
+same solver. Finaly, with input and output formater is possible to
+execute a code on distant computer, for example, over ssh.
+
+#+name: graph-multi-solver
+#+header: :results drawer
+#+header: :exports results
+#+header: :post attr_wrap(width="12cm", data=*this*, name="graph-multi-solver", caption="Scheme of multiple solver configured, one Rubarbe solver and two Mage solver with one on local machine and one on a distant machine accessed over ssh", float="t")
+#+begin_src dot :file "images/auto_graph-multi-solver.png" :cache no
+  digraph {
+      bgcolor="transparent";
+      node[colorscheme=set19,shape=box,style="filled",fillcolor=9];
+      edge[colorscheme=set19,color=0];
+
+      subgraph cluster00 {
+          label="User personal computer";
+          style=solid;
+
+          subgraph cluster0 {
+              label="Pamhyr2";
+              style=solid;
+
+              // subgraph cluster01 {
+              //    label="Core";
+                  //model[label="Model", fillcolor=2];
+                  //view[label="View", fillcolor=1];
+                  config[label="Configuration", fillcolor=5];
+
+                  // view -> model -> view;
+              // }
+
+              subgraph cluster02 {
+                  label="Solver";
+                  style=dashed;
+                  subgraph cluster021 {
+                      label="Solver Classes";
+                      classSolverM7[label="Mage7", fillcolor=6];
+                      classSolverM8[label="Mage8", fillcolor=6];
+                      classSolverR[label="RubarBE", fillcolor=6];
+                  }
+                  //classSolverX[label="Solver X Binding", fillcolor=6];
+
+                  subgraph cluster022 {
+                      label="Solver Object";
+                      solverM[label="Mage", fillcolor=6];
+                      solverM2[label="Mage over ssh", fillcolor=6];
+                      solverR[label="RubarBE", fillcolor=6];
+                      //solverX[label="Solver X", fillcolor=6];
+                  }
+
+                  classSolverM8 -> solverM [style=dashed];
+                  classSolverM8 -> solverM2[style=dashed];
+                  classSolverR -> solverR[style=dashed];
+                  //classSolverX -> solverX[style=dashed];
+              }
+
+              //config -> solverM[style="dotted"];
+              //config -> solverR[style="dotted"];
+              //config -> solverX[style="dotted"];
+
+              //model -> solverM;
+              //model -> solverM2;
+              //model -> solverR;
+              //model -> solverX;
+          }
+
+          subgraph cluster1 {
+              label="File System";
+              style=dashed;
+
+              mage[label="Mage Binary",shape=note];
+              //X[label="Solver X Binary"];
+              rubarbe[label="RubarBE Binary",shape=note];
+              ssh[label="ssh",shape=note];
+          }
+      }
+
+      //config -> X[style=invis];
+      //model -> config[style=invis];
+      config -> solverM[label="",constraint=true];
+      //config -> solverX[label="",constraint=true];
+      config -> solverR[label="",constraint=true];
+      config -> solverM2[label="",constraint=true];
+
+      subgraph cluster2 {
+          label="Distant server";
+          style=solid;
+
+          sshd[label="sshd"];
+
+          subgraph cluster21 {
+              label="File System";
+              style=dashed;
+
+              mage2[label="Mage Binary",shape=note];
+          }
+      }
+
+      solverM -> mage[label="", color=1];
+      mage -> solverM[label="", color=2];
+
+      //solverX -> X[label="", color=1];
+      //X -> solverX[label="", color=2];
+
+      solverR -> rubarbe[label="", color=1];
+      rubarbe -> solverR[label="", color=2];
+
+      solverM2 -> ssh -> sshd -> mage2[label="", color=1];
+      mage2 -> sshd -> ssh -> solverM2[label="", color=2];
+  }
+#+end_src
+
+Let see Figure [[graph-pipeline]] the temporal order of action to run a
+solver and get results:
+ - (1) Write solver input file(s) using the study data
+ - (2) Run the solver
+ - (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.1) The Pamhyr2 solver class read solver output file(s) and
+   complete Results with readed data
 
 #+name: graph-pipeline
 #+header: :results drawer
 #+header: :exports results
-#+header: :post attr_wrap(width="12cm", data=*this*, name="graph-pipeline", caption="Pamhyr2 solver execution pipeline architecture scheme", float="t")
+#+header: :post attr_wrap(width="10cm", data=*this*, name="graph-pipeline", caption="Pamhyr2 solver execution pipeline architecture scheme", float="t")
-#+begin_src dot :file "images/graph-pipeline.png" :cache no
+#+begin_src dot :file "images/auto_graph-pipeline.png" :cache no
   digraph {
         bgcolor="transparent";
         node[colorscheme=set19,shape=box,style="filled",fillcolor=9];
+        edge[colorscheme=set19,color=0];
 
         subgraph cluster0 {
             label="Pamhyr2"
-            config[label="Config",fillcolor=5];
+            config[label="Configuration",fillcolor=5];
             model[label="Model",fillcolor=2];
             obj[label="Solver",fillcolor=6];
             results[label="Results",fillcolor=2];
@@ -271,26 +858,130 @@ https://doc.qt.io/qt-5/model-view-programming.html
         obj -> model[style="dashed"];
 
         subgraph cluster1{
-            label="System";
+            label="File System";
-            in[label="Solver input files",shape=note];
+            style=dashed;
-            out[label="Solver output files",shape=note];
+            in[label="Solver input file(s)",shape=note,fillcolor=white];
+            out[label="Solver output file(s)",shape=note,fillcolor=white];
             bin[label="Solver binary",shape=note];
         }
 
-        obj -> in[label="Write (1)"];
+        obj -> in[label="Write (1)",color=1];
-        obj -> bin[label="Execute (2)"];
+        obj -> bin[label="Execute (2)",color=1];
-        bin -> in[label="Read (2.1)"];
+        bin -> in[label="Read (2.1)",color=1];
-        bin -> out[label="Write (2.2)"];
+        bin -> out[label="Write (2.2)",color=2];
-        obj -> results[label="Create (3)"];
+        obj -> results[label="Create (3)",color=2];
-        obj -> out[label="Read (3.1)"];
+        obj -> out[label="Read (3.1)", color=2];
         view -> model[style="dashed"];
         view -> results[style="dashed"];
   }
 #+end_src
 
-** TODO Unit tests
+In case of generic solver (or a solver with input and output formater)
-** TODO The debug mode
+the temporal order of action is prensented in Figure
-* TODO Build the project
+[[graph-pipeline-generic]].
+
+#+name: graph-pipeline-generic
+#+header: :results drawer
+#+header: :exports results
+#+header: :post attr_wrap(width="12cm", data=*this*, name="graph-pipeline-generic", caption="Pamhyr2 generic solver execution pipeline architecture scheme", float="t")
+#+begin_src dot :file "images/auto_graph-pipeline-generic.png" :cache no
+  digraph {
+        bgcolor="transparent";
+        node[colorscheme=set19,shape=box,style="filled",fillcolor=9];
+        edge[colorscheme=set19,color=0];
+
+        subgraph cluster0 {
+            label="Pamhyr2"
+            config[label="Configuration",fillcolor=5];
+            model[label="Model",fillcolor=2];
+            obj[label="Generic solver",fillcolor=6];
+            results[label="Results",fillcolor=2];
+            view[label="View",fillcolor=1];
+
+            results -> model[style="dashed"];
+            results -> obj[style="dashed"];
+        }
+
+        config -> obj[label=""];
+        obj -> model[style="dashed"];
+
+        subgraph cluster1{
+            label="File System";
+            style=dashed;
+
+            gin[label="Generic input file", shape=note,fillcolor=white];
+            ibin[label="Input formater", shape=note];
+            in[label="Solver input file(s)",shape=note,fillcolor=white];
+            out[label="Solver output file(s)",shape=note,fillcolor=white];
+            gout[label="Generic results file",shape=note,fillcolor=white];
+            obin[label="Output formater", shape=note];
+            bin[label="Solver binary",shape=note];
+        }
+
+        gin -> ibin[style=invis];
+        ibin -> bin -> obin[style=invis];
+        in -> bin[style=invis];
+        obin -> gout[style=invis];
+
+        // Input format
+        obj -> gin[label="Write (1)",color=1];
+        obj -> ibin[label="Execute (2)",color=1,style=dashed];
+        ibin -> gin[label="Read (2.1)",color=1];
+        ibin -> in[label="Write (2.2)",color=1];
+
+        // Solve
+        obj -> bin[label="Execute (3)",color=1,style=dashed];
+        bin -> in[label="Read (3.1)",color=1];
+        bin -> out[label="Write (3.2)",color=2];
+
+        // Output format
+        obj -> obin[label="Execute (4)",color=2,style=dashed];
+        obin -> out[label="Read (4.1)",color=2];
+        obin -> gout[label="Write (4.2)",color=2];
+
+        // Read results
+        obj -> results[label="Create (5)",color=2];
+        obj -> gout[label="Read (5.1)", color=2];
+        view -> model[style="dashed"];
+        view -> results[style="dashed"];
+  }
+#+end_src
+
+To implement a Solver in Pamhyr2, there exists a abstract class
+=Solver.AbstractSolver=. A class who herits this class, must implement
+different methods:
+ - =export=: Export the study to solver input file(s)
+ - =input_param=: Return the solver input parameter(s) as string
+ - =log_file=: Return the solver log file name as string
+ - =results=: Read the solver output file(s) and return a
+   =Model.Results= object.
+
+** Unit tests
+
+The unit tests is actually not implemented in Pamhyr2, it is a *work
+in progress*.
+
+** The debug mode
+
+To activate an deactivate the Pamhyr2 debug mode you can open the
+configuration window and type "Ctrl+G" or run Pamhyr2 with command
+line:
+#+begin_src shell
+./Pamhyr2 debug
+#+end_src
+
+This mode add some log and add two action in main window menu:
+"About/Debug" open a window with Python Repl in current Python
+environement, and "About/Debug SQLite" who open the application
+SQLiteBrowser (if installed) on current Study to explore the study
+data base file.
+
+#+NAME: debug-repl
+#+ATTR_LATEX: :width 12cm
+#+CAPTION: Pamhyr2 debug Python REPL
+[[./images/python-debug-repl.png]]
+
+* Build the project
 
 The project uses gitlab-ci runners to build packages, but it is possible
 to build packages manually.
@@ -335,7 +1026,45 @@ winetricks installed.
 
 [fn:nsis] The NSIS web site: https://sourceforge.net/projects/nsis/
 
-** TODO Setup the CI environment
+** Setup the CI environment
+
+Pamhyr2 need a Linux ci-runner and a Windows ci-runner for building
+package. The windows ci-runner could run on a Wine environement.
+
+*** Linux
+
+The Linux ci-runner need some software and dependencies in addtion of
+gitlab-ci.
+
+#+begin_src shell
+  sudo apt install                                \
+       emacs emacs-goodies-el                     \
+       texlive-full                               \
+       python3.8 python3.8-venv
+  sudo python3 -m pip install pyinstaller
+#+end_src
+
+*** Windows (Wine)
+
+The ci-runner environment for Wine need at least wine version 8, let
+[[https://www.numetopia.fr/comment-installer-wine-sur-ubuntu-ou-linux-mint/][see who to add wine official depot to your linux distribution]].
+
+#+begin_src shell
+sudo apt install wine-stable winetricks
+#+end_src
+
+In addition, the environment need windows version of:
+ - [[https://www.python.org/ftp/python/3.8.10/python-3.8.10-amd64.exe][Python 3.8.10]]
+ - Git
+ - PowerShell
+ - Gitlab-ci
+ - [[https://freefr.dl.sourceforge.net/project/nsis/NSIS%203/3.08/nsis-3.08-setup.exe][Nsis]]
+
+Now, we can install =pyinstaller= on this windows environment:
+#+begin_src shell
+wine python -m pip install pyinstaller
+#+end_src
+
 * Documentation files
 
 This document and the user documentation are org files. This text file

doc/users/Tuto1/data/Bief_1.ST

@@ -0,0 +1,442 @@
+     1     0     0     8   31090.0000   
+   31090.0000       0.0000      23.7300 
+   31090.0000       2.5000      20.2800 rg
+   31090.0000       2.5000      19.2900 
+   31090.0000       4.4000      19.2900 
+   31090.0000      10.7000      19.5900 
+   31090.0000      10.7000      20.5900 rd
+   31090.0000      14.5000      21.7100 
+   31090.0000      17.6000      23.7300 
+     999.9990     999.9990     999.9990 
+     2     0     0     8   31165.0000   
+   31165.0000       0.0000      22.8400 
+   31165.0000       2.5000      20.1300 rg
+   31165.0000       2.5000      19.2300 
+   31165.0000       4.4000      19.2300 
+   31165.0000      10.7000      19.5300 
+   31165.0000      10.7000      20.5300 rd
+   31165.0000      14.5000      21.7500 
+   31165.0000      17.6000      23.5000 
+     999.9990     999.9990     999.9990 
+     3     0     0    10   31425.0000   
+   31425.0000      -1.0000      22.8000 
+   31425.0000       0.0000      21.9000 
+   31425.0000       1.7000      20.3600 rg
+   31425.0000       2.5000      19.6300 
+   31425.0000       2.5000      19.0300 
+   31425.0000       4.4000      19.0300 
+   31425.0000      10.7000      19.3300 
+   31425.0000      10.7000      20.3300 rd
+   31425.0000      14.5000      21.9200 
+   31425.0000      17.6000      23.4200 
+     999.9990     999.9990     999.9990 
+     4     0     0    10   31590.0000   
+   31590.0000      -1.0000      22.7500 
+   31590.0000       0.0000      22.0500 
+   31590.0000       1.6700      20.2200 rg
+   31590.0000       2.5000      19.3100 
+   31590.0000       2.5000      18.9000 
+   31590.0000       4.4000      18.9000 
+   31590.0000      10.7000      19.2000 
+   31590.0000      10.7000      20.2000 rd
+   31590.0000      14.5000      22.0200 
+   31590.0000      17.6000      23.2500 
+     999.9990     999.9990     999.9990 
+     5     0     0    10   31780.0000   
+   31780.0000      -1.0000      22.7000 
+   31780.0000       0.0000      22.0500 
+   31780.0000       1.6000      20.0500 rg
+   31780.0000       2.5000      18.9400 
+   31780.0000       2.5000      18.7500 
+   31780.0000       4.4000      18.7500 
+   31780.0000      10.7000      19.0500 
+   31780.0000      10.7000      20.0500 rd
+   31780.0000      14.5000      22.1400 
+   31780.0000      17.6000      23.0000 
+     999.9990     999.9990     999.9990 
+     6     0     0     9   31874.0000   
+   31874.0000       0.0000      22.9900 
+   31874.0000       0.0000      22.6900 
+   31874.0000       2.5000      19.6900 rg
+   31874.0000       2.5000      18.6900 
+   31874.0000       4.4000      18.6900 
+   31874.0000      10.7000      18.9900 
+   31874.0000      10.7000      19.9900 rd
+   31874.0000      14.5000      22.1900 
+   31874.0000      17.6000      22.9900 
+     999.9990     999.9990     999.9990 
+     7     0     0     9   31875.0000   PontRD101m
+   31875.0000       0.5400      23.0000 
+   31875.0000       0.5400      21.8900 
+   31875.0000       2.5000      19.6900 rg
+   31875.0000       2.5000      18.6900 
+   31875.0000       4.4000      18.6900 
+   31875.0000      10.7000      18.9900 
+   31875.0000      10.7000      19.9900 rd
+   31875.0000      13.8900      21.8900 
+   31875.0000      13.8900      23.0000 
+     999.9990     999.9990     999.9990 
+     8     0     0     9   31885.0000   PontRD101v
+   31885.0000       0.5400      23.0000 
+   31885.0000       0.5400      21.8900 
+   31885.0000       2.5000      19.6900 rg
+   31885.0000       2.5000      18.6900 
+   31885.0000       4.4000      18.6900 
+   31885.0000      10.7000      18.9900 
+   31885.0000      10.7000      19.9900 rd
+   31885.0000      13.8900      21.8900 
+   31885.0000      13.8900      23.0000 
+     999.9990     999.9990     999.9990 
+     9     0     0     9   31886.0000   
+   31886.0000       0.0000      22.9900 
+   31886.0000       0.0000      22.6900 
+   31886.0000       2.5000      19.6900 rg
+   31886.0000       2.5000      18.6900 
+   31886.0000       4.4000      18.6900 
+   31886.0000      10.7000      18.9900 
+   31886.0000      10.7000      19.9900 rd
+   31886.0000      14.5000      22.1900 
+   31886.0000      17.6000      22.9900 
+     999.9990     999.9990     999.9990 
+    10     0     0    13   32015.0000   
+   32015.0000       0.0000      22.6400 
+   32015.0000       0.2000      22.2200 
+   32015.0000       1.3000      20.9900 
+   32015.0000       2.0000      19.8800 rg
+   32015.0000       3.0000      18.6600 
+   32015.0000       3.0000      18.5800 
+   32015.0000       5.5000      18.5800 
+   32015.0000      10.0000      18.9100 
+   32015.0000      11.5000      19.2500 
+   32015.0000      11.5000      20.0800 rd
+   32015.0000      15.1000      22.0600 
+   32015.0000      17.6000      22.5100 
+   32015.0000      18.0000      22.8100 
+     999.9990     999.9990     999.9990 
+    11     0     0    13   32205.0000   
+   32205.0000       0.0000      22.3300 
+   32205.0000       0.2000      22.1800 
+   32205.0000       1.5000      21.0600 
+   32205.0000       2.5000      19.7700 rg
+   32205.0000       3.6000      18.5100 
+   32205.0000       3.6000      18.4500 
+   32205.0000       6.9000      18.4500 
+   32205.0000       8.8000      19.0500 
+   32205.0000      12.5000      19.5700 rd
+   32205.0000      12.5000      20.1800 
+   32205.0000      15.8000      21.9000 
+   32205.0000      18.1000      22.4000 
+   32205.0000      18.6000      22.5500 
+     999.9990     999.9990     999.9990 
+    12     0     0    13   32460.0000   
+   32460.0000       0.0000      22.1500 
+   32460.0000       0.3000      22.1300 
+   32460.0000       1.8000      21.1600 
+   32460.0000       3.0000      19.6400 rg
+   32460.0000       4.4000      18.3100 
+   32460.0000       4.4000      18.2800 
+   32460.0000       8.7000      18.2800 
+   32460.0000      10.4000      19.2400 rd
+   32460.0000      13.7000      19.9900 
+   32460.0000      13.7000      20.3300 
+   32460.0000      16.8000      21.6800 
+   32460.0000      18.9000      22.2500 
+   32460.0000      19.3000      22.5500 
+     999.9990     999.9990     999.9990 
+    13     0     0    13   32655.0000   
+   32655.0000       0.0000      22.4500 
+   32655.0000       0.3000      22.0900 
+   32655.0000       2.1000      21.2300 
+   32655.0000       3.4000      19.5300 rg
+   32655.0000       5.0000      18.1600 
+   32655.0000       5.0000      18.1400 
+   32655.0000      10.1000      18.1400 
+   32655.0000      11.6000      19.3900 rd
+   32655.0000      14.7000      20.3100 
+   32655.0000      14.7000      20.4300 
+   32655.0000      17.5000      21.5200 
+   32655.0000      19.4000      22.1400 
+   32655.0000      19.8000      22.4500 
+     999.9990     999.9990     999.9990 
+    14     0     0    13   32755.0000   
+   32755.0000       0.0000      22.4500 
+   32755.0000       0.3000      22.0900 
+   32755.0000       2.1000      21.2300 
+   32755.0000       3.4000      19.5300 rg
+   32755.0000       4.0000      18.0500 
+   32755.0000       5.0000      18.0100 
+   32755.0000      10.1000      18.0100 
+   32755.0000      13.0000      19.3900 rd
+   32755.0000      14.7000      20.3100 
+   32755.0000      14.7000      20.4300 
+   32755.0000      17.5000      21.5200 
+   32755.0000      19.4000      22.1400 
+   32755.0000      19.8000      22.4500 
+     999.9990     999.9990     999.9990 
+    15     0     0    10   32770.0000   PontA2
+   32770.0000       0.0000      25.0000 
+   32770.0000       1.9000      25.0000 
+   32770.0000       1.9000      21.2700 
+   32770.0000       3.3000      19.4700 rg
+   32770.0000       5.0000      18.0100 
+   32770.0000      10.5000      18.0100 
+   32770.0000      12.0000      19.4700 rd
+   32770.0000      19.4000      21.4700 
+   32770.0000      19.4000      25.0000 
+   32770.0000      20.3000      25.0000 
+     999.9990     999.9990     999.9990 
+    16     0     0    10   32800.0000   PontA2
+   32800.0000       0.0000      25.0000 
+   32800.0000       1.9000      25.0000 
+   32800.0000       1.9000      21.2700 
+   32800.0000       3.3000      19.4700 rg
+   32800.0000       5.0000      18.0100 
+   32800.0000      10.5000      18.0100 
+   32800.0000      12.0000      19.4700 rd
+   32800.0000      19.4000      21.4700 
+   32800.0000      19.4000      25.0000 
+   32800.0000      20.3000      25.0000 
+     999.9990     999.9990     999.9990 
+    17     0     0    13   32820.0000   
+   32820.0000       0.0000      22.4500 
+   32820.0000       0.3000      22.0900 
+   32820.0000       2.1000      21.2300 
+   32820.0000       3.4000      19.5300 rg
+   32820.0000       4.0000      18.0500 
+   32820.0000       5.0000      18.0100 
+   32820.0000      10.1000      18.0100 
+   32820.0000      13.0000      19.3900 rd
+   32820.0000      14.7000      20.3100 
+   32820.0000      14.7000      20.4300 
+   32820.0000      17.5000      21.5200 
+   32820.0000      19.4000      22.1400 
+   32820.0000      19.8000      22.4500 
+     999.9990     999.9990     999.9990 
+    18     0     0    11   32915.0000   
+   32915.0000       0.0000      22.5500 
+   32915.0000       0.4000      21.9500 
+   32915.0000       1.7000      21.2200 
+   32915.0000       2.4000      20.9700 
+   32915.0000       3.8000      19.4100 rg
+   32915.0000       3.9000      19.3100 
+   32915.0000       5.8000      18.0100 
+   32915.0000      11.0000      18.0100 
+   32915.0000      12.4000      19.3400 rd
+   32915.0000      19.4000      21.9900 
+   32915.0000      19.7000      22.5500 
+     999.9990     999.9990     999.9990 
+    19     0     0    10   33140.0000   
+   33140.0000       0.4000      21.7700 
+   33140.0000       1.9000      20.7600 
+   33140.0000       2.7000      20.5100 
+   33140.0000       4.2000      19.1500 rg
+   33140.0000       4.3000      19.0600 
+   33140.0000       6.4000      17.9200 
+   33140.0000      11.3000      17.9200 
+   33140.0000      12.6000      19.1400 rd
+   33140.0000      18.9000      21.8700 
+   33140.0000      19.2000      22.1800 
+     999.9990     999.9990     999.9990 
+    20     0     0    10   33425.0000   
+   33425.0000       0.0000      21.6800 
+   33425.0000       0.5000      21.5300 
+   33425.0000       2.2000      20.1600 
+   33425.0000       3.0000      19.9400 
+   33425.0000       4.8000      18.8200 rg
+   33425.0000       4.9000      18.7500 
+   33425.0000       7.2000      17.8000 
+   33425.0000      11.7000      17.8000 
+   33425.0000      12.8000      18.8800 rd
+   33425.0000      18.2000      21.6800 
+     999.9990     999.9990     999.9990 
+    21     0     0    10   33685.0000   
+   33685.0000       0.0000      21.5300 
+   33685.0000       0.5000      21.3200 
+   33685.0000       2.4000      19.6200 
+   33685.0000       3.3000      19.4200 
+   33685.0000       5.2000      18.5300 rg
+   33685.0000       5.4000      18.4700 
+   33685.0000       7.9000      17.7000 
+   33685.0000      12.0000      17.7000 
+   33685.0000      12.9000      18.6500 rd
+   33685.0000      17.6000      21.5300 
+     999.9990     999.9990     999.9990 
+    22     0     0     9   33920.0000   
+   33920.0000       0.6000      20.9800 
+   33920.0000       2.6000      19.1300 
+   33920.0000       3.6000      18.9400 
+   33920.0000       5.7000      18.2600 rg
+   33920.0000       5.8000      18.2200 
+   33920.0000       8.5000      17.6000 
+   33920.0000      12.3000      17.6000 
+   33920.0000      13.1000      18.4400 rd
+   33920.0000      17.0000      21.1300 
+     999.9990     999.9990     999.9990 
+    23     0     0     9   34095.0000   
+   34095.0000       0.6000      20.9500 
+   34095.0000       2.7000      18.7700 
+   34095.0000       3.8000      18.5900 
+   34095.0000       6.0000      18.0600 rg
+   34095.0000       6.1000      18.0300 
+   34095.0000       9.0000      17.5300 
+   34095.0000      12.5000      17.5300 
+   34095.0000      13.2000      18.2800 rd
+   34095.0000      16.6000      20.9800 
+     999.9990     999.9990     999.9990 
+    24     0     0    10   34295.0000   
+   34295.0000       0.0000      21.3600 
+   34295.0000       0.6000      20.8300 
+   34295.0000       2.4000      18.3500 
+   34295.0000       3.5000      18.1900 
+   34295.0000       5.8000      17.8300 rg
+   34295.0000       6.5000      17.3400 
+   34295.0000       9.5000      17.3600 
+   34295.0000      12.8000      17.4100 
+   34295.0000      14.0000      18.1000 rd
+   34295.0000      16.1000      21.3600 
+     999.9990     999.9990     999.9990 
+    25     0     0    10   34334.0000   amontPontThivencel
+   34334.0000       0.0000      21.3600 
+   34334.0000       0.6000      20.8300 
+   34334.0000       2.4000      18.3500 
+   34334.0000       3.5000      18.1900 
+   34334.0000       5.8000      17.8300 rg
+   34334.0000       6.5000      17.3400 
+   34334.0000       9.5000      17.3600 
+   34334.0000      12.8000      17.4100 
+   34334.0000      14.0000      18.1000 rd
+   34334.0000      16.1000      21.1300 
+     999.9990     999.9990     999.9990 
+    26     0     0     9   34335.0000   PontmThivencelle
+   34335.0000       2.9000      22.0000 
+   34335.0000       2.9000      20.7400 
+   34335.0000       2.9000      18.2900 rg
+   34335.0000       6.4000      17.7900 
+   34335.0000       9.6000      17.2600 
+   34335.0000      12.8000      17.2600 
+   34335.0000      12.8000      18.3100 rd
+   34335.0000      12.8000      20.7400 
+   34335.0000      12.8000      22.0000 
+     999.9990     999.9990     999.9990 
+    27     0     0     9   34343.0000   PontvThivencelle
+   34343.0000       2.9000      22.0000 
+   34343.0000       2.9000      20.7400 
+   34343.0000       2.9000      18.2900 rg
+   34343.0000       6.4000      17.7900 
+   34343.0000       9.6000      17.2600 
+   34343.0000      12.8000      17.2600 
+   34343.0000      12.8000      18.2900 rd
+   34343.0000      12.8000      20.7400 
+   34343.0000      12.8000      22.0000 
+     999.9990     999.9990     999.9990 
+    28     0     0    10   34345.0000   avalPontThivencell
+   34345.0000       0.0000      21.3600 
+   34345.0000       0.6000      20.8300 
+   34345.0000       2.4000      18.3500 
+   34345.0000       3.5000      18.1900 
+   34345.0000       5.8000      17.8300 rg
+   34345.0000       6.5000      17.3400 
+   34345.0000       9.5000      17.2600 
+   34345.0000      12.8000      17.4100 
+   34345.0000      14.0000      18.1000 rd
+   34345.0000      16.1000      21.1300 
+     999.9990     999.9990     999.9990 
+    29     0     0     7   34405.0000   
+   34405.0000       0.0000      21.1400 
+   34405.0000       2.9000      17.8400 rg
+   34405.0000       6.4000      17.4400 
+   34405.0000       9.6000      17.2000 
+   34405.0000      12.8000      17.2200 
+   34405.0000      13.9000      17.8400 rd
+   34405.0000      19.0000      21.0000 
+     999.9990     999.9990     999.9990 
+    30     0     0     7   34535.0000   
+   34535.0000       0.0000      20.5900 
+   34535.0000       2.9000      17.7400 rg
+   34535.0000       6.4000      17.2400 
+   34535.0000       9.6000      17.0300 
+   34535.0000      12.8000      17.0300 
+   34535.0000      13.5000      17.7400 rd
+   34535.0000      15.8000      20.6000 
+     999.9990     999.9990     999.9990 
+    31     0     0     7   34705.0000   
+   34705.0000       0.0000      20.5000 
+   34705.0000       2.9000      17.6100 rg
+   34705.0000       6.4000      17.1100 
+   34705.0000       9.6000      16.8500 
+   34705.0000      12.8000      16.8500 
+   34705.0000      14.0000      18.0000 rd
+   34705.0000      16.2000      20.5300 
+     999.9990     999.9990     999.9990 
+    32     0     0     7   34825.0000   
+   34825.0000       0.0000      20.6200 
+   34825.0000       2.9000      17.5200 rg
+   34825.0000       6.4000      17.0200 
+   34825.0000       9.6000      16.7100 
+   34825.0000      12.8000      16.7100 
+   34825.0000      13.5000      17.5200 rd
+   34825.0000      16.2000      20.5000 
+     999.9990     999.9990     999.9990 
+    33     0     0     7   34995.0000   
+   34995.0000       0.0000      20.3900 
+   34995.0000       2.9000      17.3900 rg
+   34995.0000       6.4000      16.8900 
+   34995.0000       9.6000      16.5300 
+   34995.0000      12.8000      16.5300 
+   34995.0000      13.6000      17.4300 rd
+   34995.0000      16.2000      20.3200 
+     999.9990     999.9990     999.9990 
+    34     0     0     7   35135.0000   
+   35135.0000       0.0000      20.1600 
+   35135.0000       2.9000      17.2900 rg
+   35135.0000       6.4000      16.7900 
+   35135.0000       9.6000      16.4300 
+   35135.0000      12.8000      16.4300 
+   35135.0000      13.9000      17.3700 rd
+   35135.0000      16.2000      20.0600 
+     999.9990     999.9990     999.9990 
+    35     0     0     7   35360.0000   
+   35360.0000       0.0000      19.8600 
+   35360.0000       2.9000      17.1200 rg
+   35360.0000       6.4000      16.6200 
+   35360.0000       9.6000      16.2600 
+   35360.0000      12.8000      16.2600 
+   35360.0000      13.7000      17.1200 rd
+   35360.0000      16.2000      19.4600 
+     999.9990     999.9990     999.9990 
+    36     0     0     7   35580.0000   
+   35580.0000       0.0000      20.0000 
+   35580.0000       2.9000      16.9500 rg
+   35580.0000       3.0000      16.0900 
+   35580.0000      11.5000      16.0500 
+   35580.0000      20.0000      16.0900 
+   35580.0000      21.0000      17.0300 rd
+   35580.0000      23.0000      19.5000 
+     999.9990     999.9990     999.9990 
+    37     0     0     7   35920.0000   
+   35920.0000       0.0000      20.0000 
+   35920.0000       2.2000      16.0200 rg
+   35920.0000       3.0000      14.5500 
+   35920.0000      11.5000      14.5000 
+   35920.0000      20.0000      14.5500 
+   35920.0000      20.9000      16.0200 rd
+   35920.0000      23.0000      19.5000 
+     999.9990     999.9990     999.9990 
+    38     0     0     7   36270.0000   S1
+   36270.0000       0.0000      20.0000 
+   36270.0000       1.8000      17.0100 rg
+   36270.0000       3.0000      15.0800 
+   36270.0000      11.5000      15.0500 
+   36270.0000      20.0000      15.0800 
+   36270.0000      21.3000      17.0100 rd
+   36270.0000      23.0000      19.5000 
+     999.9990     999.9990     999.9990 
+    39     0     0     7   36271.0000   S1bis
+   36271.0000       0.0000      20.0000 
+   36271.0000       1.8000      17.0100 rg
+   36271.0000       3.0000      13.0800 
+   36271.0000      11.5000      13.0500 
+   36271.0000      20.0000      13.0800 
+   36271.0000      21.3000      17.0100 rd
+   36271.0000      23.0000      19.5000 
+     999.9990     999.9990     999.9990 

doc/users/Tuto1/data/Cote_canal

@@ -0,0 +1,2 @@
+0:00:00:00	15
+0:00:01:00	15

doc/users/Tuto1/data/Fevrier_2002

@@ -0,0 +1,25 @@
+0:00:00:00	5,53
+0:11:37:00	5,72
+0:16:17:00	5,82
+0:22:57:00	5,92
+1:00:00:00	6,6
+1:00:57:00	8,04
+1:02:29:00	14,3
+1:04:38:00	24,4
+1:08:48:00	40
+1:11:27:00	46,3
+1:13:47:00	48,8
+1:16:07:00	47,9
+1:17:17:00	44,8
+1:20:23:00	27,8
+1:21:57:00	24,3
+2:01:15:00	19,2
+2:05:15:00	15,8
+2:11:25:00	11,5
+2:11:57:00	11,1
+2:13:17:00	10,5
+2:19:07:00	9,84
+2:23:59:00	8,43
+3:04:51:00	7,02
+3:09:43:00	5,61
+3:14:35:00	5,53

doc/users/Tuto1/data/Hogneau.SIN

@@ -0,0 +1,25 @@
+**************** SINGULARITES **********************
+*BieSec Nb Longueur  Cote dev Cote charg Coef deb            Impression         
+*===---===----------==========----------==========----------------------------- 
+*****************************************************
+* Bief n°  1
+*****************************************************
+* Ouvrage au pk 36270.0  seuil_aval
+*SeuilR type D
+D  1  36270.00    18.250    15.500     0.000     0.400 99999.000 seuil palplanches
+* Ouvrage au pk 31875.0  PontRS101
+*OrificeR type O
+O  1  31875.00     9.660    18.710    21.890     0.400  9999.000 
+*SeuilR type D
+D  1  31875.00    14.000    22.890     0.000     0.400 99999.000 
+* Ouvrage au pk 34335.0  PontThivencelle
+*SeuilR type D
+D  1  34335.00    13.000    21.740     0.000     0.400 99999.000 
+*OrificeR type O
+O  1  34335.00     9.070    17.280    20.740     0.400  9999.000 
+*****************************************************
+* Bief n°  3
+*****************************************************
+* Ouvrage au pk 0.0  Orifice
+*OrificeR type O
+*O  3     0.000     6.000    19.000    19.001     0.400    20.000 Clapet_001

doc/users/Tuto1/data/Hogneau.var

@@ -0,0 +1 @@
+$Clapet_001  clapet

doc/users/Tuto1/data/Q_permanent

@@ -0,0 +1,2 @@
+0:00:00:00	4
+0:00:01:00	4

doc/users/Tuto1/data/Seuil_aval_23m

@@ -0,0 +1,24 @@
+16,03	0
+16,13	1,29
+16,23	3,64
+16,33	6,7
+16,43	10,31
+16,53	14,41
+16,63	18,94
+16,73	23,87
+16,83	29,16
+16,93	34,79
+17,03	40,75
+17,13	47,01
+17,23	53,57
+17,33	60,4
+17,43	67,5
+17,53	74,86
+17,63	82,47
+17,73	90,33
+17,83	98,41
+17,93	106,73
+18,03	115,26
+18,13	124,01
+18,23	132,98
+18,33	142,14

doc/users/Tuto1/data/T_100ans

@@ -0,0 +1,9 @@
+0:00:00:00	4
+0:01:16:48	4
+0:16:00:00	50
+1:11:46:28	36,8
+2:07:27:22	23,3
+5:04:24:58	13,8
+10:03:00:06	9,38
+20:02:19:58	7,29
+30:01:54:37	5,97

doc/users/Tuto1/data/T_10ans

@@ -0,0 +1,10 @@
+0:00:00:00	4
+0:01:49:48	4
+0:16:00:00	35
+1:11:25:48	25
+2:07:30:00	16,4
+5:03:55:12	9,66
+10:03:00:00	6,56
+27:00:54:00	4,91
+30:01:48:36	4
+31:06:00:00	4

doc/users/Tuto1/step-by-step.tex

@@ -0,0 +1,267 @@
+%% LyX 2.0.2 created this file.  For more info, see http://www.lyx.org/.
+%% Do not edit unless you really know what you are doing.
+\documentclass[12pt,french]{article}
+\usepackage[T1]{fontenc}
+\usepackage[latin9]{inputenc}
+\usepackage{geometry}
+\geometry{verbose,tmargin=2cm,bmargin=2cm,lmargin=2cm,rmargin=2cm,headheight=2cm,headsep=2cm,footskip=2cm}
+\usepackage{textcomp}
+\usepackage{graphicx}
+\usepackage{hyperref}
+
+\makeatletter
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% LyX specific LaTeX commands.
+\newcommand{\noun}[1]{\textsc{#1}}
+%% Because html converters don't know tabularnewline
+\providecommand{\tabularnewline}{\\}
+
+\makeatother
+
+\usepackage{babel}
+\addto\extrasfrench{%
+   \providecommand{\og}{\leavevmode\flqq~}%
+   \providecommand{\fg}{\ifdim\lastskip>\z@\unskip\fi~\frqq}%
+}
+
+\begin{document}
+\includegraphics[width=5cm]{Logo-INRAE_Transparent.png}
+
+~
+
+~
+
+~
+
+\begin{center}
+Tutorial for Pamhyr2
+
+January 2024
+\par\end{center}
+
+~
+
+~
+
+\begin{center}
+\textbf{\LARGE 1D Modeling of the Hogneau River (Nord, France)}
+
+using Pamhyr2
+\par\end{center}{\LARGE \par}
+
+~
+
+~
+
+\begin{center}
+{\large INRAE Lyon-Grenoble Auvergne-Rhône-Alpes}
+\par\end{center}{\large \par}
+
+\begin{center}
+Riverly, river hydraulics
+\par\end{center}
+
+~
+
+~
+
+~
+
+~
+
+~
+
+~
+
+\begin{center}
+\begin{tabular}{lll}
+Autors : & Pierre-Antoine Rouby & pierre-antoine.rouby@inrae.fr\tabularnewline
+& Théophile TERRAZ & theophile.terraz@inrae.fr\tabularnewline
+\end{tabular}
+\par\end{center}
+
+~
+
+\pagebreak{}
+
+\begin{center}
+\tableofcontents{}
+\par\end{center}
+
+~
+
+\pagebreak{}
+
+\section{Introduction}
+
+TODO
+
+\pagebreak{}
+
+\section{Install Pamhyr2}
+
+Pamhyr2 can be downloaded from \url{https://gitlab.irstea.fr/theophile.terraz/pamhyr}.
+\begin{center}
+\includegraphics[width=15cm]{dl.png}
+\par\end{center}
+
+Use the GNU Linux or the Windows download button depending on your system. On windows, launch the installer. On Linux, unpack the archive and launch Pamhyr2.
+
+
+\section{Create your first study}
+
+On the main windows, click on \texttt{[Files] => [New Study]} to create a new study.
+
+Click on \texttt{[River Network] => [Edit River Network]} to create the reaches of your river. In this window, you must define an oriented graph that represents the reaches of your river network: the edges are the reaches and the nodes are either upstream boundary conditions, downstream boundary conditions or junctions.
+Press the \includegraphics[width=0.5cm]{gtk_add.png} to enter the \textit{add} mode. Create two nodes by clicking in the grey zone of the window, and create a link by clicking again on each node. press \includegraphics[width=0.5cm]{gtk_add.png} again to exit the \textit{add} mode. You created your first reach, with an upstream node and a downstream node. In the lower part of the \textit{Edit River Network} window you can rename the nodes and the reaches. As the reach you created is automaticaly selected, all the next steps will apply to this reach. The window should look like that:
+
+\begin{center}
+\includegraphics[width=15cm]{network.png}
+\par\end{center}
+
+Close the \textit{Edit River Network} window.
+
+
+\section{Edit the river geometry}
+
+Click on \texttt{[Geometry] => [Edit Geometry]} to define the geometry of the selected bief. Click on the \texttt{[Import]} button and select the file \texttt{Data/Bief\_1.st}. You should see:
+
+\begin{center}
+\includegraphics[width=15cm]{Geo.png}
+\par\end{center}
+
+On the left panel is a list of all the cross sections with their name and longitudinal abscisa. In the top left plot you can see the top view of the river, on the top right panel the longitudinal cross-section of the river and in the bottom plot you can see the selected cross-section (blue) along with the next one (dashed purple) and previous one (dashed black). You can move in the section list using the slider at the very right of the window.
+
+You can edit the selected cross section by clicking on the \includegraphics[width=0.5cm]{"../../../src/View/ui/ressources/edit.png"} icon.
+
+select the cross section named \textit{PontRD101m} and open the edition window. You should see:
+
+\begin{center}
+\includegraphics[width=15cm]{editsect.png}
+\par\end{center}
+
+On the left panel is the list of all the points of the section, with their coordinates, their name and their transversal absisa. The Z coordinate of the highest point is written in blue and the lowest in red. Points can have a name. If a point with the same name exists in every section in a reach, it forms a longitudinal line. For example, here we have \textit{rg} and \textit{rd} which represent the left bank and the right bank of the main chanel.
+
+On the plot is a projection of the cross section. You can use \texttt{[ctrl + click]} to select a point in the plot and \texttt{[shift + click]} to select a water line and fisualize usefull geometric data. You can close the cross section edition window and the geometry edition window.
+
+\section{Edit the boundary conditions}
+
+From the main window, click on \texttt{[Hydraulics] => [Boundary conditions and punctual contributions]}.You should see:
+
+\begin{center}
+\includegraphics[width=15cm]{boundary.png}
+\par\end{center}
+
+ Use the \textit{add} button on the top left of the window to add a liquid boundary condition.
+ On the new line, click to select the whole line, double click to select the cell.
+ Select the \textit{Type} cell to give a name to the boundary condition. here, we will define the flow discharge mesured during the february 2002 flood. You can name this boundary condition "flood2002".
+ Select the \textit{Type} cell and use the combo box to put a Q(t) law.
+ Select the \textit{Node} cell and atribute this condition to the upstream node.
+ Names of the nodes are recalled in network in the right panel.
+ Now select the whole line and click on the edit button \includegraphics[width=0.5cm]{"../../../src/View/ui/ressources/edit.png"}. You opened the \textit{Edit Boundary Conditions} window.
+ On a text editor, open the \texttt{Data/Fevrier\_2002.txt} file. Copy the content of the file (for example with \textit{ctrl+a ctrl+c}) and paste it in the left panel of the \textit{Edit Boundary Conditions} window with \textit{ctrl+v}. You can now see the flow discharge curve:
+
+\begin{center}
+\includegraphics[width=15cm]{fev2002.png}
+\par\end{center}
+
+Close this window. Go back on the \textit{Boundary Conditions} window. Add a new line, give it a name, give it the textit{Z(T)} type and associate it to the downstream node of the network. Open the \textit{Edit Boundary Conditions} window (\includegraphics[width=0.5cm]{"../../../src/View/ui/ressources/edit.png"}). Add two lines. In the first one, enter time: 0.00.00 and Z: 15.000.
+On the second one, time: 1.00.00 and Z: 15.000. It creates a constant downstream water elevation. For the computaion, Mage will extrapolate continuously the water elevation, that's why we only need to define one hour.
+You can close the the \textit{Edit Boundary Conditions} and the \textit{Boundary Conditions} window.
+
+\section{Create initial conditions}
+
+From the main window, click on \texttt{[Hydraulics] => [Initial conditions]}.
+If you don't know the initial conditions in water elevation and flow discharge of the river, you can use \texttt{[Generate minimal height]} or \texttt{[Generate constant discharge]} buttons to let Pamhyr2 estimate an initial condition using the Manning-Strickler formula.
+Click on \texttt{[Generate minimal height]} and enter a discharge of $4 m^2$ in the pop-up window to generate an initial water height condition based on the Manning-Strickler formula and a uniform discharge of $4 m^2$. You should see:
+
+\begin{center}
+\includegraphics[width=15cm]{ic.png}
+\par\end{center}
+
+Close the \textit{Initial conditions} window.
+
+
+\section{Edit friction coefficients}
+
+From the main window, click on \texttt{[Hydraulics] => [Edit friction]}.
+You fist have to define sets of Strickler coefficients. Click on \includegraphics[width=0.5cm]{"../../../src/View/ui/ressources/edit.png"} to open the \textit{Strickler} window. Here you can create couples of Strickler coefficients, the first one for the minor bed, the second one for the medium bed. Click on \textit{add} four times to create four new couple. Give them the folowing values:
+
+\begin{center}
+\includegraphics[width=15cm]{K.png}
+\par\end{center}
+
+Close the \textit{Strickler} window. On the \textit{Edit friction} window, add four lines with the button \includegraphics[width=0.5cm]{gtk_add.png} to create four friction zones. Each zone is defined by a \textit{begin} and \textit{end} PK and a \textit{begin} and \textit{end} Strickler couple. The strickler coefficient couples inside a zone are interpolated from the \textit{begin} and \textit{end} couples. In our case, we will use constant coefficients per zone. Set the zones as follow:
+
+\begin{center}
+\includegraphics[width=15cm]{frictions.png}
+\par\end{center}
+
+The selected zone is highlighted in blue. Close the \textit{Edit friction} window.
+
+
+\section{Model hydraulic structures}
+
+Sometimes there can be cross-sections in which Shallow water equations can not be used to model the water flow. In that case, we have to define an other law to link the water elevation and the flow discharge. This is the case, for example, under bridges when the water elevation is too high, leading to a flow in charge. Pamhyr2 enables to define various hydraulic structures with laws that can be parametrized. In our case, a weir and two bridges have to be represented as hydraulic structures.
+From the main window, click on \texttt{[Hydraulics] => [Hydraulic structures]} to open the hydraulic structures window. Click tree times on the \includegraphics[width=0.5cm]{gtk_add.png} button to create three hydraulic structures. Each structure can have a name and must have a reach and a kp. Set them as follow:
+
+\begin{center}
+\includegraphics[width=15cm]{hs.png}
+\par\end{center}
+
+Select the downstream weir and click on \includegraphics[width=0.5cm]{"../../../src/View/ui/ressources/edit.png"} to edit the laws of this structure. Hydraulic structures are composed of basic hydraulic structures. You can combine the laws of several basic hydraulic structures to setup your structure. For this weir, we only need a weir basic hydraulic structure. Click on \includegraphics[width=0.5cm]{gtk_add.png} to add a new basic hydraulic structure, give it the \textit{weir} type and set it up as folow:
+
+\begin{center}
+\includegraphics[width=15cm]{seuil.png}
+\par\end{center}
+
+Go back to the \textit{hydraulic structures} window.
+
+Select the RS101 bridge and click on \includegraphics[width=0.5cm]{"../../../src/View/ui/ressources/edit.png"} to edit the laws of this structure. A bridge can be modeled as a combination of an orifice for the flow under the bridge and a weir for the flow over the bridge. Create two basic hydraulic structures and set them as folow:
+
+\begin{center}
+\includegraphics[width=15cm]{seuilRS101.png}
+
+\includegraphics[width=15cm]{orificeRS101.png}
+\par\end{center}
+
+Go back to the \textit{hydraulic structures} window and aply the same procedure for the Thivencelle bridge:
+
+\begin{center}
+\includegraphics[width=15cm]{orificeThivencelle.png}
+
+\includegraphics[width=15cm]{seuilThivencelle.png}
+\par\end{center}
+
+You can now close the \textit{hydraulic structures} windows.
+
+\section{Solver parameters}
+
+From the main window, click on \texttt{[Execute] => [Numerical parameters for solvers]}.
+In the window \textit{solver parameters} select the \textit{Mage v8} tab. Set the solver parameters as follow:
+
+\begin{center}
+\includegraphics[width=15cm]{param.png}
+\par\end{center}
+
+Close the \textit{solver parameters} window.
+
+\section{Run the simulation}
+
+From the main window, click on \texttt{[Execute] => [Run solver]}.
+Select \textit{Defaut-Mage - (Mage8)} anc click on the \textit{Run} button.
+It will open two windows: the \textit{Check list} window and the \textit{Solver log} window.
+The \textit{Check list} window gives som hints about the validity of your model, and the \textit{Solver log} window displays the outputs of the solver.
+From the \textit{Solver log} window you can re-run the computation, and from the textit{Solver log} window you can click on the \textit{Results} button to open the \textit{Results} window.
+
+\section{Visualize the results}
+
+If you closed the textit{Solver log} window, you can click on \texttt{[Results] => [Visualize last results]} from the main window to open the \textit{Results} window. The top lets panel let you select your reach, the bottom left panel lets you select a cross-section in that reach. the tree plots on the right show the reach and the cross-section the same way than in the \textit{Geometry} window. You can use the bottom slider to visualize the water elevation at different timesteps.
+To visualize the flow discharge, switch to the \textit{Hydrograph} tab.
+To create custom 2D plots, click on the \includegraphics[width=0.5cm]{gtk_add.png} button on the top left of the window. Select the values you want on the $X$ and $Y$ axis and click on \textit{OK}.
+You can now see a new tab with the custom 2D plot in the right panel of the \textit{Results} window.
+
+
+\pagebreak{}
+\end{document}
+

doc/users/build.sh

@@ -1,10 +1,18 @@
 #! /bin/sh
 
-# Build the PDF
+echo " PDF  documentation.org"
-
+emacs -nw --batch                                       \
-emacs -Q -q -nw --batch                                 \
       --eval "(require 'org)"                           \
       --eval "(require 'ox-latex)"                      \
       --eval "(load-file \"../tools/setup.el\")"        \
       --file ./documentation.org                        \
       -f org-latex-export-to-pdf
+
+echo " HTML documentation.org"
+emacs -nw --batch                                       \
+      --eval "(require 'org)"                           \
+      --eval "(require 'ox-latex)"                      \
+      --eval "(require 'ox-html)"                       \
+      --eval "(load-file \"../tools/setup.el\")"        \
+      --file ./documentation.org                        \
+      -f org-html-export-to-html

full-requirements.txt

@@ -0,0 +1,12 @@
+PyQt5==5.15.4
+PyQt5-Qt5==5.15.2
+PyQt5-sip==12.12.2
+PyQtWebEngine==5.15.6
+QScintilla>=2.14.1
+pyqtgraph>=0.12.1
+matplotlib>=3.4.1
+numpy>=1.24.2
+colorama>=0.4.3
+pyinstaller>=5.11.0
+shapely>=2.0.1
+lxml>=4.9.3

packages/linux.sh

@@ -25,6 +25,7 @@ echo " *** SETUP ENV"
 
 python3 -m venv linux-pamhyr-venv
 . linux-pamhyr-venv/bin/activate
+pip3 install -U pip
 pip3 install -r ../requirements.txt
 
 echo " *** PYINSTALL"
@@ -43,18 +44,22 @@ cd $OLD_PWD
 
 echo " *** COPY DATA"
 
-mkdir -p dist/pamhyr/View/ui
+mkdir -p dist/pamhyr/_internal/View/ui
-mkdir -p dist/pamhyr/View/ui/Widgets
+mkdir -p dist/pamhyr/_internal/View/ui/Widgets
-cp -r ../src/View/ui/ressources/ dist/pamhyr/View/ui/
+cp -r ../src/View/ui/ressources/ dist/pamhyr/_internal/View/ui/
-cp -r ../src/View/ui/Widgets/*.ui dist/pamhyr/View/ui/Widgets/
+cp -r ../src/View/ui/Widgets/*.ui dist/pamhyr/_internal/View/ui/Widgets/
-cp -r ../src/View/ui/*.ui dist/pamhyr/View/ui/
+cp -r ../src/View/ui/*.ui dist/pamhyr/_internal/View/ui/
 
 mkdir -p dist/pamhyr/lang
 cp -r ../src/lang/*.qm dist/pamhyr/lang/
 
-cp ../VERSION dist/pamhyr/
+mkdir dist/pamhyr/_internal/
-cp ../AUTHORS dist/pamhyr/
+#cp ../VERSION dist/pamhyr/_internal/
-cp ../LICENSE dist/pamhyr/
+VERSION=$(cat ../VERSION)
+echo "local-build-$VERSION" > dist/pamhyr/_internal/VERSION
+cp ../AUTHORS dist/pamhyr/_internal/
+cp ../LICENSE dist/pamhyr/_internal/
+cp ../src/motd.txt dist/pamhyr/_internal/
 
 mkdir -p dist/pamhyr/mage/
 cp ../mage/mage dist/pamhyr/mage/
@@ -65,6 +70,18 @@ mkdir -p dist/pamhyr/tests_cases/
 mkdir -p dist/pamhyr/tests_cases/Saar
 cp ../tests_cases/Saar/Saar.pamhyr dist/pamhyr/tests_cases/Saar/
 
+mkdir -p dist/pamhyr/doc/
+cp ../doc/dev/documentation.pdf dist/pamhyr/doc/Pamhyr2-dev.pdf
+cp ../doc/dev/documentation.html dist/pamhyr/doc/Pamhyr2-dev.html
+
+cp ../doc/users/documentation.pdf dist/pamhyr/doc/Pamhyr2-users.pdf
+cp ../doc/users/documentation.html dist/pamhyr/doc/Pamhyr2-users.html
+
+mkdir -p dist/pamhyr/doc/images
+cp ../doc/users/images/* dist/pamhyr/doc/images/
+cp ../doc/dev/images/* dist/pamhyr/doc/images/
+cp ../doc/images/* dist/pamhyr/doc/images/
+
 echo " *** MAKE SRC PACKAGE"
 
 OLD_PWD=$PWD
@@ -76,11 +93,11 @@ mv ../pamhyr-src.tar.gz ./
 
 echo " *** MAKE BIN PACKAGE"
 
-OLD_PWD=$PWD
+# OLD_PWD=$PWD
-cd dist/
+# cd dist/
-tar --xz -cf pamhyr-gnulinux-amd64.tar.xz pamhyr --checkpoint=.100
+# tar --xz -cf pamhyr-gnulinux-amd64.tar.xz pamhyr --checkpoint=.100
-cd $OLD_PWD
+# cd $OLD_PWD
 
-mv dist/pamhyr-gnulinux-amd64.tar.xz ./
+# mv dist/pamhyr-gnulinux-amd64.tar.xz ./
 
 echo " *** DONE"

packages/make-windows-dir.bat

@@ -16,26 +16,27 @@ rem along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 @ECHO ON
 
-mkdir pamhyr\pamhyr
+mkdir pamhyr\pamhyr\_internal
 xcopy /s /e /y dist\pamhyr pamhyr\pamhyr
 
 rem Copy data
-mkdir pamhyr\pamhyr\lang
+mkdir pamhyr\pamhyr\_internal\lang
-mkdir pamhyr\pamhyr\View\ui\ressources
+mkdir pamhyr\pamhyr\_internal\View\ui\ressources
-mkdir pamhyr\pamhyr\View\ui\Widgets
+mkdir pamhyr\pamhyr\_internal\View\ui\Widgets
 
 rem UI
-copy /y ..\src\View\ui\ressources\ pamhyr\pamhyr\View\ui\ressources
+copy /y ..\src\View\ui\ressources\ pamhyr\pamhyr\_internal\View\ui\ressources
-copy /y ..\src\View\ui\Widgets\*.ui pamhyr\pamhyr\View\ui\Widgets
+copy /y ..\src\View\ui\Widgets\*.ui pamhyr\pamhyr\_internal\View\ui\Widgets
-copy /y ..\src\View\ui\*.ui pamhyr\pamhyr\View\ui\
+copy /y ..\src\View\ui\*.ui pamhyr\pamhyr\_internal\View\ui\
 
 rem Lang
-copy /y ..\src\lang\*.qm pamhyr\pamhyr\lang\
+copy /y ..\src\lang\*.qm pamhyr\pamhyr\_internal\lang\
 
 rem Information
-copy /y ..\VERSION pamhyr\pamhyr
+copy /y ..\VERSION pamhyr\pamhyr\_internal
-copy /y ..\AUTHORS pamhyr\pamhyr
+copy /y ..\AUTHORS pamhyr\pamhyr\_internal
-copy /y ..\LICENSE pamhyr\pamhyr
+copy /y ..\LICENSE pamhyr\pamhyr\_internal
+copy /y ..\src\motd.txt pamhyr\pamhyr\_internal
 
 rem MAGE
 mkdir pamhyr\mage
@@ -50,5 +51,11 @@ copy /y ..\tests_cases\Saar\Saar.pamhyr pamhyr\tests_cases\Saar\
 
 rem Documentations
 mkdir pamhyr\doc
+mkdir pamhyr\doc\images
 copy /y ..\doc\users\documentation.pdf pamhyr\doc\Pamhyr2-users.pdf
 copy /y ..\doc\dev\documentation.pdf pamhyr\doc\Pamhyr2-dev.pdf
+copy /y ..\doc\users\documentation.html pamhyr\doc\Pamhyr2-users.html
+copy /y ..\doc\dev\documentation.html pamhyr\doc\Pamhyr2-dev.html
+copy /y ..\doc\users\images\* pamhyr\doc\images
+copy /y ..\doc\dev\images\* pamhyr\doc\images
+copy /y ..\doc\images\* pamhyr\doc\images

packages/pamhyr.nsi

@@ -5,7 +5,7 @@
 
 Name "Pamhyr2"
 OutFile "pamhyr-windows.exe"
-LicenseData "pamhyr\pamhyr\LICENSE"
+LicenseData "pamhyr\pamhyr\_internal\LICENSE"
 LicenseText "I Agree"
 
 RequestExecutionLevel admin

requirements.txt

@@ -1,9 +1,12 @@
 PyQt5==5.15.4
 PyQt5-Qt5==5.15.2
-PyQt5-sip==12.8.1
+PyQt5-sip==12.12.2
+#PyQtWebEngine==5.15.6
+QScintilla>=2.14.1
 pyqtgraph>=0.12.1
 matplotlib>=3.4.1
 numpy>=1.24.2
 colorama>=0.4.3
 pyinstaller>=5.11.0
 shapely>=2.0.1
+lxml>=4.9.3

src/Checker/Checker.py

@@ -20,12 +20,14 @@ from enum import Enum
 
 from Model.Except import NotImplementedMethodeError
 
+
 class STATUS(Enum):
     UNKNOWN = -1
     OK = 0
     WARNING = 1
     ERROR = 2
 
+
 class AbstractModelChecker(object):
     def __init__(self):
         self._name = ""
@@ -62,6 +64,12 @@ class AbstractModelChecker(object):
 
     # Abstract function
 
+    def _run(self, study):
+        from Model.Study import Study
+
+        thread_study = Study.open(study._filename)
+        self.run(thread_study)
+
     def run(self, study):
         """Run checker function
 

src/Checker/Mage.py

@@ -27,6 +27,7 @@ from Checker.Checker import AbstractModelChecker, STATUS
 
 _translate = QCoreApplication.translate
 
+
 class MageNetworkGraphChecker(AbstractModelChecker):
     def __init__(self, connectivity=True):
         super(MageNetworkGraphChecker, self).__init__()
@@ -38,8 +39,10 @@ class MageNetworkGraphChecker(AbstractModelChecker):
         else:
             mode = "cycle"
 
-        self._name = _translate("Checker", f"Mage network graph {mode} checker")
+        self._name = _translate(
-        self._description = _translate("Checker", "Check if the network graph is valid")
+            "Checker", f"Mage network graph {mode} checker")
+        self._description = _translate(
+            "Checker", "Check if the network graph is valid")
 
     @timer
     def _connectivity(self, summary, status, graph):

src/Checker/Study.py

@@ -30,7 +30,8 @@ class StudyNetworkReachChecker(AbstractModelChecker):
         super(StudyNetworkReachChecker, self).__init__()
 
         self._name = _translate("Checker", "Study network reach checker")
-        self._description = _translate("Checker", "Check if exists at least one reach for study")
+        self._description = _translate(
+            "Checker", "Check if exists at least one reach for study")
 
     def run(self, study):
         if study is None:
@@ -54,12 +55,14 @@ class StudyNetworkReachChecker(AbstractModelChecker):
         self._status = STATUS.OK
         return True
 
+
 class StudyGeometryChecker(AbstractModelChecker):
     def __init__(self):
         super(StudyGeometryChecker, self).__init__()
 
         self._name = _translate("Checker", "Study geometry checker")
-        self._description = _translate("Checker", "Check if exists geometry for each reach of study")
+        self._description = _translate(
+            "Checker", "Check if exists geometry for each reach of study")
         self._reachs = []
 
     def run(self, study):
@@ -128,6 +131,7 @@ class DummyWARNING(AbstractModelChecker):
 
         return True
 
+
 class DummyERROR(AbstractModelChecker):
     def __init__(self):
         super(DummyERROR, self).__init__()

src/Model/BoundaryCondition/BoundaryCondition.py

@@ -25,6 +25,7 @@ from Model.Except import NotImplementedMethodeError
 
 logger = logging.getLogger()
 
+
 class BoundaryCondition(SQLSubModel):
     _sub_classes = []
     _id_cnt = 0
@@ -50,7 +51,7 @@ class BoundaryCondition(SQLSubModel):
         BoundaryCondition._id_cnt = max(BoundaryCondition._id_cnt + 1, self.id)
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         execute("""
           CREATE TABLE boundary_condition(
             id INTEGER NOT NULL PRIMARY KEY,
@@ -76,7 +77,7 @@ class BoundaryCondition(SQLSubModel):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return True
 
     @classmethod
@@ -101,7 +102,7 @@ class BoundaryCondition(SQLSubModel):
         return res
 
     @classmethod
-    def _sql_load(cls, execute, data = None):
+    def _db_load(cls, execute, data=None):
         new = []
         tab = data["tab"]
 
@@ -143,7 +144,7 @@ class BoundaryCondition(SQLSubModel):
 
         return new
 
-    def _sql_save(self, execute, data = None):
+    def _db_save(self, execute, data=None):
         tab = data["tab"]
 
         execute(f"DELETE FROM boundary_condition WHERE id = {self.id}")
@@ -157,16 +158,16 @@ class BoundaryCondition(SQLSubModel):
             "INSERT INTO " +
             "boundary_condition(id, name, type, tab, node) " +
             "VALUES (" +
-            f"{self.id}, '{self._sql_format(self._name)}', " +
+            f"{self.id}, '{self._db_format(self._name)}', " +
-            f"'{self._sql_format(self._type)}', '{tab}', {node}" +
+            f"'{self._db_format(self._type)}', '{tab}', {node}" +
             ")"
         )
         execute(sql)
 
         ind = 0
         for d in self._data:
-            data0 = self._sql_format(str(d[0]))
+            data0 = self._db_format(str(d[0]))
-            data1 = self._sql_format(str(d[1]))
+            data1 = self._db_format(str(d[1]))
 
             sql = (
                 "INSERT INTO " +
@@ -187,8 +188,13 @@ class BoundaryCondition(SQLSubModel):
 
     @classmethod
     def time_convert(cls, data):
-        if type(data) == str and data.count(":") == 3:
+        if type(data) is str:
+            if data.count(":") == 3:
                 return old_pamhyr_date_to_timestamp(data)
+            if data.count(":") == 2:
+                return old_pamhyr_date_to_timestamp("00:" + data)
+            if data.count(".") == 1:
+                return round(float(data))
 
         return int(data)
 
@@ -301,11 +307,10 @@ class BoundaryCondition(SQLSubModel):
         return self.data[index]
 
     def get_range(self, _range):
-        l = []
+        lst = []
         for r in _range:
-            l.append(r)
+            lst.append(r)
-        return l
+        return lst
-
 
     def _set_i_c_v(self, index, column, value):
         v = list(self._data[index])

src/Model/BoundaryCondition/BoundaryConditionList.py

@@ -30,6 +30,7 @@ from Model.BoundaryCondition.BoundaryConditionTypes import (
     Solid,
 )
 
+
 class BoundaryConditionList(PamhyrModelListWithTab):
     _tabs_list = ["liquid", "solid", "suspenssion"]
     _sub_classes = [
@@ -37,7 +38,7 @@ class BoundaryConditionList(PamhyrModelListWithTab):
     ]
 
     @classmethod
-    def _sql_load(cls, execute, data = None):
+    def _db_load(cls, execute, data=None):
         new = cls(status=data['status'])
 
         if data is None:
@@ -45,13 +46,13 @@ class BoundaryConditionList(PamhyrModelListWithTab):
 
         for tab in new._tabs:
             data["tab"] = tab
-            new._tabs[tab] = BoundaryCondition._sql_load(
+            new._tabs[tab] = BoundaryCondition._db_load(
                 execute, data
             )
 
         return new
 
-    def _sql_save(self, execute, data = None):
+    def _db_save(self, execute, data=None):
         execute("DELETE FROM boundary_condition")
 
         if data is None:
@@ -60,7 +61,7 @@ class BoundaryConditionList(PamhyrModelListWithTab):
         for tab in self._tabs:
             data["tab"] = tab
             for bc in self._tabs[tab]:
-                bc._sql_save(execute, data = data)
+                bc._db_save(execute, data=data)
 
         return True
 
@@ -73,18 +74,31 @@ class BoundaryConditionList(PamhyrModelListWithTab):
     def __copy__(self):
         new = BoundaryConditionList()
 
-        for l in self._tabs:
+        for lst in self._tabs:
-            new.tabs[l] = self._tabs[l].copy()
+            new.tabs[lst] = self._tabs[lst].copy()
 
         return new
 
     def __deepcopy__(self):
         new = BoundaryConditionList()
 
-        for l in self._tabs:
+        for lst in self._tabs:
-            new.tabs[l] = self._tabs[l].deepcopy()
+            new.tabs[lst] = self._tabs[lst].deepcopy()
 
         return new
 
     def copy(self):
         return copy(self)
+
+    def get_assoc_to_node(self, tab, node):
+        assoc = list(
+            filter(
+                lambda i: i.node is node,
+                self._tabs[tab]
+            )
+        )
+
+        if len(assoc) > 0:
+            return assoc[0]
+
+        return None

src/Model/BoundaryCondition/BoundaryConditionTypes.py

@@ -32,9 +32,11 @@ class NotDefined(BoundaryCondition):
     def _default_0(self):
         return 0.0
 
+
 class PonctualContribution(BoundaryCondition):
     def __init__(self, id: int = -1, name: str = "", status=None):
-        super(PonctualContribution, self).__init__(id=id, name=name, status=status)
+        super(PonctualContribution, self).__init__(
+            id=id, name=name, status=status)
 
         self._type = "PC"
         self._header = ["time", "discharge"]
@@ -44,6 +46,7 @@ class PonctualContribution(BoundaryCondition):
     def compatibility(cls):
         return ["liquid"]
 
+
 class TimeOverZ(BoundaryCondition):
     def __init__(self, id: int = -1, name: str = "", status=None):
         super(TimeOverZ, self).__init__(id=id, name=name, status=status)
@@ -56,9 +59,11 @@ class TimeOverZ(BoundaryCondition):
     def compatibility(cls):
         return ["liquid"]
 
+
 class TimeOverDischarge(BoundaryCondition):
     def __init__(self, id: int = -1, name: str = "", status=None):
-        super(TimeOverDischarge, self).__init__(id=id, name=name, status=status)
+        super(TimeOverDischarge, self).__init__(
+            id=id, name=name, status=status)
 
         self._type = "TD"
         self._header = ["time", "discharge"]
@@ -68,6 +73,7 @@ class TimeOverDischarge(BoundaryCondition):
     def compatibility(cls):
         return ["liquid"]
 
+
 class ZOverDischarge(BoundaryCondition):
     def __init__(self, id: int = -1, name: str = "", status=None):
         super(ZOverDischarge, self).__init__(id=id, name=name, status=status)

src/Model/Except.py

@@ -45,6 +45,7 @@ def exception_message_box(exception):
 # Custom error #
 ################
 
+
 class ExeceptionWithMessageBox(Exception):
     def __init__(self, title="Exeception"):
         self.title = title
@@ -81,12 +82,16 @@ class NotImplementedMethodeError(ExeceptionWithMessageBox):
         self.alert()
 
     def __str__(self):
+        class_type = self.obj
+        if self.obj.__class__ != type:
+            class_type = self.obj.__class__
+
         return (
             _translate("Exception", "Method") +
             f" '{self.func.__name__}' " +
             _translate("Exception", "not implemented") +
             _translate("Exception", "for class") +
-            f" '{self.obj.__class__ if self.obj.__class__ != type else self.obj}'"
+            f" '{class_type}'"
         )
 
     def header(self):
@@ -104,6 +109,7 @@ class NotImplementedMethodeError(ExeceptionWithMessageBox):
             f" '{self.obj.__class__}'"
         )
 
+
 class FileFormatError(ExeceptionWithMessageBox):
     def __init__(self, filename, reason):
         super(FileFormatError, self).__init__(

src/Model/Friction/Friction.py

@@ -16,10 +16,15 @@
 
 # -*- coding: utf-8 -*-
 
+import logging
+
 from tools import trace, timer
 
 from Model.Tools.PamhyrDB import SQLSubModel
 
+logger = logging.getLogger()
+
+
 class Friction(SQLSubModel):
     def __init__(self, name: str = "", status=None):
         super(Friction, self).__init__()
@@ -34,7 +39,7 @@ class Friction(SQLSubModel):
         self._end_strickler = None
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         execute("""
           CREATE TABLE friction(
             id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
@@ -53,13 +58,14 @@ class Friction(SQLSubModel):
         return True
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return True
 
     @classmethod
-    def _sql_load(cls, execute, data = None):
+    def _db_load(cls, execute, data=None):
         new = []
-        reach = data["parent"]  # Reach object
+
+        reach = data["reach"]
         status = data["status"]
         stricklers = data["stricklers"].stricklers
 
@@ -68,9 +74,6 @@ class Friction(SQLSubModel):
             f"FROM friction WHERE reach = {reach.id}"
         )
 
-        for _ in table:
-            new.append(None)
-
         for row in table:
             ind = row[0]
             # Get stricklers
@@ -85,15 +88,16 @@ class Friction(SQLSubModel):
             sec.begin_strickler = bs
             sec.end_strickler = es
 
-            new[ind] = sec
+            new.append((ind, sec))
 
         return new
 
-    def _sql_save(self, execute, data = None):
+    def _db_save(self, execute, data=None):
         ind = data["ind"]
         execute(
             "INSERT INTO " +
-            "friction(ind, begin_kp, end_kp, reach, begin_strickler, end_strickler) " +
+            "friction(ind, begin_kp, end_kp, " +
+            "reach, begin_strickler, end_strickler) " +
             "VALUES (" +
             f"{ind}, {self._begin_kp}, {self._end_kp}, " +
             f"{self._edge.id}, " +
@@ -116,6 +120,10 @@ class Friction(SQLSubModel):
     def edge(self):
         return self._edge
 
+    @property
+    def reach(self):
+        return self._edge
+
     @edge.setter
     def edge(self, edge):
         self._edge = edge
@@ -129,6 +137,15 @@ class Friction(SQLSubModel):
     def has_edge(self):
         return self._edge is not None
 
+    def has_coefficient(self):
+        return (
+            self._begin_strickler is not None and
+            self._end_strickler is not None
+        )
+
+    def is_full_defined(self):
+        return self.has_edge() and self.has_coefficient()
+
     @property
     def begin_kp(self):
         return self._begin_kp

src/Model/Friction/FrictionList.py

@@ -28,46 +28,71 @@ from Model.Friction.Friction import Friction
 
 logger = logging.getLogger()
 
+
 class FrictionList(PamhyrModelList):
     _sub_classes = [
         Friction
     ]
 
     @classmethod
-    def _sql_update_0_0_1(cls, execute, version):
+    def _db_update_0_0_1(cls, execute, version):
         execute("ALTER TABLE `section` RENAME TO `friction`")
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         if version == "0.0.0":
             logger.info(f"Update friction TABLE from {version}")
-            cls._sql_update_0_0_1(execute, version)
+            cls._db_update_0_0_1(execute, version)
 
         return True
 
     @classmethod
-    def _sql_load(cls, execute, data = None):
+    def _db_load(cls, execute, data=None):
         new = cls(status=data['status'])
 
-        new._lst = Friction._sql_load(
+        ilst = Friction._db_load(
             execute, data
         )
 
+        new._lst = list(map(lambda x: x[1], sorted(ilst)))
+
         return new
 
-    def _sql_save(self, execute, data = None):
+    def _db_save(self, execute, data=None):
+        frictions = self.lst
+
         reach = data["reach"]
         execute(f"DELETE FROM friction WHERE reach = {reach.id}")
 
         ok = True
         ind = 0
-        for friction in self._lst:
+        for friction in frictions:
             data["ind"] = ind
-            ok &= friction._sql_save(execute, data = data)
+            ok &= friction._db_save(execute, data=data)
             ind += 1
 
         return ok
 
+    def _get_frictions_list(self):
+        # Frictions list generator is type (int, Point) with the first
+        # element the index of the Point in list
+        return list(
+            map(
+                lambda p: p[1],
+                sorted(
+                    self._lst,
+                    key=lambda p: p[0]
+                )
+            )
+        )
+
+    @property
+    def lst(self):
+        if not isinstance(self._lst, list):
+            self._lst = self._get_frictions_list()
+
+        return self._lst
+
     @property
     def frictions(self):
         return self.lst

src/Model/Geometry/Point.py

@@ -18,6 +18,7 @@
 
 from Model.Except import NotImplementedMethodeError
 
+
 class Point(object):
     def __init__(self, name: str = "", profile=None, status=None):
         super(Point, self).__init__()
@@ -28,7 +29,6 @@ class Point(object):
         self._profile = profile
         self._sl = None
 
-
     @property
     def sl(self):
         if self._sl is None:
@@ -40,7 +40,7 @@ class Point(object):
     def sl(self, sl):
         if sl == self._profile.sl:
             self._sl = None
-
+        else:
             self._sl = sl
 
     @property

src/Model/Geometry/PointXY.py

@@ -20,6 +20,7 @@ from math import dist
 
 from Model.Geometry.Point import Point
 
+
 class PointAC(Point):
     def __init__(self, a: float = 0.0, c: float = 0.0,
                  name: str = "", status=None):

src/Model/Geometry/PointXYZ.py

@@ -22,19 +22,21 @@ import numpy as np
 from Model.Tools.PamhyrDB import SQLSubModel
 from Model.Geometry.Point import Point
 
+
 class PointXYZ(Point, SQLSubModel):
     _sub_classes = []
 
     def __init__(self, x: float = 0.0, y: float = 0.0, z: float = 0.0,
                  name: str = "", profile=None, status=None):
-        super(PointXYZ, self).__init__(name=name, profile=profile, status=status)
+        super(PointXYZ, self).__init__(
+            name=name, profile=profile, status=status)
 
         self._x = float(x)
         self._y = float(y)
         self._z = float(z)
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         execute("""
           CREATE TABLE geometry_pointXYZ(
             id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
@@ -53,7 +55,7 @@ class PointXYZ(Point, SQLSubModel):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         cls._update_submodel(execute, version)
 
         major, minor, release = version.strip().split(".")
@@ -69,9 +71,7 @@ class PointXYZ(Point, SQLSubModel):
         return True
 
     @classmethod
-    def _sql_load(cls, execute, data = None):
+    def _db_load(cls, execute, data=None):
-        points = []
-
         status = data["status"]
         profile = data["profile"]
 
@@ -81,10 +81,6 @@ class PointXYZ(Point, SQLSubModel):
             f"WHERE profile = {profile.id}"
         )
 
-        # Create points list
-        for _ in table:
-            points.append(None)
-
         # Fill points list with new point
         for row in table:
             ind = row[0]
@@ -101,7 +97,7 @@ class PointXYZ(Point, SQLSubModel):
                 status=status
             )
 
-            if sl == -1 or sl == None:
+            if sl == -1 or sl is None:
                 new._sl = None
             else:
                 new._sl = next(
@@ -111,21 +107,19 @@ class PointXYZ(Point, SQLSubModel):
                     )
                 )
 
-            points[ind] = new
+            yield ind, new
 
-        return points
+    def _db_save(self, execute, data=None):
-
-    def _sql_save(self, execute, data = None):
         profile = data["profile"]
         ind = data["ind"]
 
         sl = self._sl.id if self._sl is not None else -1
 
         sql = (
-            "INSERT OR REPLACE INTO " +
+            "INSERT INTO " +
             "geometry_pointXYZ(ind, name, x, y, z, profile, sl) " +
             "VALUES (" +
-            f"{ind}, '{self._sql_format(self._name)}', " +
+            f"{ind}, '{self._db_format(self._name)}', " +
             f"{self.x}, {self.y}, {self.z}, " +
             f"{profile.id}, {sl}" +
             ")"
@@ -134,7 +128,6 @@ class PointXYZ(Point, SQLSubModel):
 
         return True
 
-
     @classmethod
     def from_data(cls, header, data):
         point = None
@@ -157,7 +150,6 @@ class PointXYZ(Point, SQLSubModel):
 
         return point
 
-
     def __repr__(self):
         return f"({self._x}, {self._y}, {self._z}, {self._name})"
 

src/Model/Geometry/Profile.py

@@ -25,6 +25,7 @@ from Model.Except import NotImplementedMethodeError
 
 logger = logging.getLogger()
 
+
 class Profile(object):
     _id_cnt = 0
 
@@ -56,16 +57,35 @@ class Profile(object):
 
         self._profile_type = _type
 
+    def __len__(self):
+        return len(self.points)
+
     @property
     def number_points(self):
-        return len(self._points)
+        return len(self.points)
+
+    def _get_points_list(self):
+        # Points list generator is type (int, Point) with the first
+        # element the index of the Point in list
+        return list(
+            map(
+                lambda p: p[1],
+                sorted(
+                    self._points,
+                    key=lambda p: p[0]
+                )
+            )
+        )
 
     @property
     def points(self):
-        return self._points.copy()
+        if not isinstance(self._points, list):
+            self._points = self._get_points_list()
+
+        return self._points
 
     def point(self, index):
-        return self._points[index]
+        return self.points[index]
 
     @property
     def reach(self):
@@ -112,7 +132,7 @@ class Profile(object):
 
     @property
     def nb_points(self):
-        return len(self._points)
+        return len(self.points)
 
     @property
     def kp(self):
@@ -167,8 +187,8 @@ class Profile(object):
         self._status.modified()
 
     def point(self, i: int):
-        if i < len(self._points):
+        if i < len(self.points):
-            return self._points[i]
+            return self.points[i]
 
         return None
 
@@ -178,10 +198,9 @@ class Profile(object):
         Returns:
             The list of named point
         """
-        return [point for point in self._points
+        return [point for point in self.points
                 if point.point_is_named()]
 
-
     def insert_point(self, index: int, point: Point):
         """Insert point at index.
 
@@ -192,7 +211,7 @@ class Profile(object):
         Returns:
             Nothing.
         """
-        self._points.insert(index, point)
+        self.points.insert(index, point)
         self._status.modified()
 
 
@@ -209,31 +228,17 @@ class Profile(object):
         self._status.modified()
 
 
-    def delete(self, indexes: int):
+    def delete_i(self, indexes: list):
-        """Delete points at index
+        self._points = list(
-
-        Args:
-            indexes: List of index of points.
-
-        Returns:
-            Nothing.
-        """
-        points = set(
             map(
                 lambda e: e[1],
                 filter(
-                    lambda e: e[0] in indexes,
+                    lambda e: e[0] not in indexes,
                     enumerate(self.points)
                 )
             )
         )
 
-        self._points = list(
-            filter(
-                lambda p: p not in points,
-                self.points
-            )
-        )
         self._status.modified()
 
     def delete_points(self, points):
@@ -256,10 +261,10 @@ class Profile(object):
     # Move
 
     def move_up_point(self, index: int):
-        if index < len(self._points):
+        if index < len(self.points):
             next = index - 1
 
-            p = self._points
+            p = self.points
             p[index], p[next] = p[next], p[index]
             self._status.modified()
 
@@ -267,7 +272,7 @@ class Profile(object):
         if index >= 0:
             prev = index + 1
 
-            p = self._points
+            p = self.points
             p[index], p[prev] = p[prev], p[index]
             self._status.modified()
 
@@ -275,14 +280,14 @@ class Profile(object):
 
     @timer
     def sort(self, column, is_reversed: bool = False):
-        predicate = lambda p: p.x
+        def predicate(p): return p.x
         if column == 'y':
-            predicate = lambda p: p.y
+            def predicate(p): return p.y
         elif column == 'z':
-            predicate = lambda p: p.z
+            def predicate(p): return p.z
 
         self._points = sorted(
-            self._points,
+            self.points,
             key=predicate,
             reverse=is_reversed
         )
@@ -290,7 +295,7 @@ class Profile(object):
 
     @timer
     def sort_with_indexes(self, indexes: list):
-        if len(self._points) != len(indexes):
+        if len(self.points) != len(indexes):
             logger.critical("Indexes list do not correspond to point list")
 
         self._points = list(
@@ -340,3 +345,13 @@ class Profile(object):
     # Abstract method, must be implemented for in non abstract class
     def get_station(self):
         raise NotImplementedMethodeError(self, self.get_station)
+
+    # Computation method
+
+    # Abstract method for width approximation
+    def width_approximation(self):
+        raise NotImplementedMethodeError(self, self.width_approximation)
+
+    # Abstract method for width approximation
+    def get_water_limits(self, z):
+        raise NotImplementedMethodeError(self, self.get_water_limits)

src/Model/Geometry/ProfileXYZ.py

@@ -16,6 +16,7 @@
 
 # -*- coding: utf-8 -*-
 
+import logging
 import numpy as np
 from typing import List
 
@@ -27,6 +28,9 @@ from Model.Geometry.Profile import Profile
 from Model.Geometry.PointXYZ import PointXYZ
 from Model.Geometry.Vector_1d import Vector1d
 
+logger = logging.getLogger()
+
+
 class ProfileXYZ(Profile, SQLSubModel):
     _sub_classes = [
         PointXYZ,
@@ -65,7 +69,7 @@ class ProfileXYZ(Profile, SQLSubModel):
         )
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         execute("""
           CREATE TABLE geometry_profileXYZ(
             id INTEGER NOT NULL PRIMARY KEY,
@@ -85,7 +89,7 @@ class ProfileXYZ(Profile, SQLSubModel):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         major, minor, release = version.strip().split(".")
         if major == minor == "0":
             if int(release) < 2:
@@ -100,7 +104,7 @@ class ProfileXYZ(Profile, SQLSubModel):
         return cls._update_submodel(execute, version)
 
     @classmethod
-    def _sql_load(cls, execute, data = None):
+    def _db_load(cls, execute, data=None):
         profiles = []
         status = data["status"]
         reach = data["reach"]
@@ -108,12 +112,9 @@ class ProfileXYZ(Profile, SQLSubModel):
         table = execute(
             "SELECT id, ind, name, kp, num, code1, code2, sl " +
             "FROM geometry_profileXYZ " +
-            f"WHERE reach = {reach}"
+            f"WHERE reach = {reach.id}"
         )
 
-        for _ in table:
-            profiles.append(None)
-
         for row in table:
             id = row[0]
             ind = row[1]
@@ -128,11 +129,11 @@ class ProfileXYZ(Profile, SQLSubModel):
                 id=id, num=num,
                 name=name, kp=kp,
                 code1=code1, code2=code2,
-                reach = data["parent"],
+                reach=reach,
                 status=status
             )
 
-            if sl == -1 or sl == None:
+            if sl == -1 or sl is None:
                 new._sl = None
             else:
                 new._sl = next(
@@ -143,13 +144,11 @@ class ProfileXYZ(Profile, SQLSubModel):
                 )
 
             data["profile"] = new
-            new._points = PointXYZ._sql_load(execute, data)
+            new._points = PointXYZ._db_load(execute, data.copy())
 
-            profiles[ind] = new
+            yield ind, new
 
-        return profiles
+    def _db_save(self, execute, data=None):
-
-    def _sql_save(self, execute, data = None):
         ok = True
         ind = data["ind"]
 
@@ -157,22 +156,25 @@ class ProfileXYZ(Profile, SQLSubModel):
 
         sql = (
             "INSERT OR REPLACE INTO " +
-            "geometry_profileXYZ(id, ind, name, reach, kp, num, code1, code2, sl) "+
+            "geometry_profileXYZ(id, ind, name, reach, " +
+            "kp, num, code1, code2, sl) " +
             "VALUES (" +
-            f"{self.id}, {ind}, '{self._sql_format(self._name)}', " +
+            f"{self.id}, {ind}, '{self._db_format(self._name)}', " +
             f"{self.reach.id}, {self.kp}, {self.num}, " +
             f"{self.code1}, {self.code1}, {sl}" +
             ")"
         )
         execute(sql)
 
+        points = self.points
+
         data["profile"] = self
         execute(f"DELETE FROM geometry_pointXYZ WHERE profile = {self.id}")
 
         ind = 0
-        for point in self._points:
+        for point in points:
             data["ind"] = ind
-            ok &= point._sql_save(execute, data)
+            ok &= point._db_save(execute, data)
             ind += 1
 
         return ok
@@ -182,11 +184,20 @@ class ProfileXYZ(Profile, SQLSubModel):
         profile = None
         try:
             if len(header) == 0:
+                name = data[0]
+                kp = data[1]
+                reach = data[2]
+                status = data[3]
+
                 profile = cls(
-                    *data
+                    id=-1,
+                    name=name,
+                    kp=kp,
+                    reach=reach,
+                    status=status
                 )
             else:
-                valid_header = {'name', 'reach', 'kp'}
+                valid_header = {'name', 'reach', 'kp', 'status'}
                 d = {}
                 for i, v in enumerate(data):
                     h = header[i].strip().lower().split(' ')[0]
@@ -195,6 +206,7 @@ class ProfileXYZ(Profile, SQLSubModel):
 
                 profile = cls(**d)
         except Exception as e:
+            logger.error(e)
             raise ClipboardFormatError(header, data)
 
         return profile
@@ -220,18 +232,17 @@ class ProfileXYZ(Profile, SQLSubModel):
 
         return point
 
-
     def x(self):
-        return [point.x for point in self._points]
+        return [point.x for point in self.points]
 
     def y(self):
-        return [point.y for point in self._points]
+        return [point.y for point in self.points]
 
     def z(self):
-        return [point.z for point in self._points]
+        return [point.z for point in self.points]
 
     def names(self):
-        return [point.name for point in self._points]
+        return [point.name for point in self.points]
 
     def x_max(self):
         return max(self.filter_isnan(self.x()))
@@ -262,7 +273,7 @@ class ProfileXYZ(Profile, SQLSubModel):
         """
         for point in list_points:
             pt = PointXYZ(*point, profile=self, status=self._status)
-            self._points.append(pt)
+            self.points.append(pt)
         self._status.modified()
 
     def get_point_i(self, index: int) -> PointXYZ:
@@ -275,10 +286,31 @@ class ProfileXYZ(Profile, SQLSubModel):
             The point.
         """
         try:
-            return self._points[index]
+            return self.points[index]
         except IndexError:
             raise IndexError(f"Invalid point index: {index}")
 
+    def get_point_by_name(self, name: str) -> PointXYZ:
+        """Get point by name.
+
+        Args:
+            name: Point name.
+
+        Returns:
+            The point.
+        """
+        try:
+            n_name = name.lower().strip()
+            return next(
+                filter(
+                    lambda p: p.name.lower().strip() == n_name,
+                    self.points
+                )
+            )
+        except Exception as e:
+            logger.debug(f"{e}")
+            raise IndexError(f"Invalid point name: {name}")
+
     def add(self):
         """Add a new PointXYZ to profile.
 
@@ -286,7 +318,7 @@ class ProfileXYZ(Profile, SQLSubModel):
             Nothing.
         """
         point_xyz = PointXYZ(0., 0., 0., profile=self, status=self._status)
-        self._points.append(point_xyz)
+        self.points.append(point_xyz)
         self._status.modified()
 
     def insert(self, index: int):
@@ -299,7 +331,7 @@ class ProfileXYZ(Profile, SQLSubModel):
             The new point.
         """
         point = PointXYZ(0., 0., 0., profile=self, status=self._status)
-        self._points.insert(index, point)
+        self.points.insert(index, point)
         self._status.modified()
         return point
 
@@ -315,9 +347,9 @@ class ProfileXYZ(Profile, SQLSubModel):
         return [x for x in lst if not np.isnan(x)]
 
     def _first_point_not_nan(self):
-        first_point = self._points[0]
+        first_point = self.points[0]
 
-        for point in self._points:
+        for point in self.points:
             if not point.is_nan():
                 first_point = point
                 break
@@ -325,9 +357,9 @@ class ProfileXYZ(Profile, SQLSubModel):
         return first_point
 
     def _last_point_not_nan(self):
-        last_point = self._points[-1]
+        last_point = self.points[-1]
 
-        for point in self._points[::-1]:
+        for point in self.points[::-1]:
             if not point.is_nan():
                 last_point = point
                 break
@@ -354,13 +386,13 @@ class ProfileXYZ(Profile, SQLSubModel):
             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):
+            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):
+            for point in reversed(self.points):
                 if point.point_is_named():
                     last_named_point = point
                     break
@@ -373,28 +405,28 @@ class ProfileXYZ(Profile, SQLSubModel):
                 if (first_named_point != last_named_point and
                         first_named_point.x != last_named_point.x):
                     vector = Vector1d(first_named_point, last_named_point)
-                    normalized_direction_vec = vector.normalized_direction_vector()
+                    norm_dir_vec = vector.normalized_direction_vector()
                 else:
                     vector = Vector1d(first_point_not_nan, last_point_not_nan)
-                    normalized_direction_vec = vector.normalized_direction_vector()
+                    norm_dir_vec = vector.normalized_direction_vector()
 
-                for point in self._points:
+                for point in self.points:
                     xi = point.x - first_named_point.x
                     yi = point.y - first_named_point.y
-                    station_i = (normalized_direction_vec[0] * xi +
+                    station_i = (norm_dir_vec[0] * xi +
-                                 normalized_direction_vec[1] * yi)
+                                 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)
-                normalized_direction_vec = vector.normalized_direction_vector()
+                norm_dir_vec = vector.normalized_direction_vector()
 
-                for point in self._points:
+                for point in self.points:
                     xi = point.x - first_point_not_nan.x
                     yi = point.y - first_point_not_nan.y
-                    station_i = (normalized_direction_vec[0] * xi +
+                    station_i = (norm_dir_vec[0] * xi +
-                                 normalized_direction_vec[1] * yi)
+                                 norm_dir_vec[1] * yi)
                     station.append(station_i)
 
                 z_min = self.z_min()
@@ -457,7 +489,7 @@ class ProfileXYZ(Profile, SQLSubModel):
         if (self.number_points <= np): return points
         while len(points) > np:
             l2 = []
-            for i in range(len(points)-2)
+            for i in range(len(points)-2):
                 l2.append(PointXYZ.angle(points(i),points(i+1),points(i+2)))
             imax = np.argmax(l2)+1
             points.pop(imax)
@@ -471,7 +503,7 @@ class ProfileXYZ(Profile, SQLSubModel):
         if (self.number_points <= np): return points
         while len(points) > np:
             l2 = []
-            for i in range(len(points)-2)
+            for i in range(len(points)-2):
                 l2.append(PointXYZ.triangle_area(points(i),points(i+1),points(i+2)))
             imin = np.argmin(l2)+1
             points.pop(imin)
@@ -479,5 +511,64 @@ class ProfileXYZ(Profile, SQLSubModel):
         return points
 
 
+    def width_approximation(self):
+        rg = self.get_point_by_name("rg")
+        rd = self.get_point_by_name("rd")
 
+        return abs(rg.dist(rd))
 
+    def get_water_limits(self, z):
+        # ====================================================================
+        #  détermination des points limites RG et RD pour un niveau
+        #  d'eau donné
+        #
+        #  irg et ird sont les premiers indices en partant des rives
+        #  gauche et droite qui correspondent à des points sous la
+        #  surface de l'eau ptX et ptY sont les points interpolés où
+        #  le plan d'eau intersecte le profil known_level est le
+        #  niveau d'eau pour lequel on a obtenu irg, ird, ptX et ptY
+        # ====================================================================
+
+        # initialisation
+        irg = -1
+        ird = -1
+
+        for i in range(self.number_points):
+            if self.point(i).z <= z:
+                irg = i
+
+        for i in reversed(range(self.number_points)):
+            if self.point(i).z <= z:
+                ird = i
+
+        # interpolation des points ptX et ptY
+        if (irg < self.number_points - 1):
+            x = np.interp(
+                z,
+                [self.point(irg).z, self.point(irg + 1).z],
+                [self.point(irg).x, self.point(irg + 1).x]
+            )
+            y = np.interp(
+                z,
+                [self.point(irg).z, self.point(irg + 1).z],
+                [self.point(irg).y, self.point(irg + 1).y]
+            )
+            ptX = PointXYZ(x, y, z)
+        else:
+            ptX = self.point(0)
+        if (ird > 0):
+            x = np.interp(
+                z,
+                [self.point(ird-1).z, self.point(ird).z],
+                [self.point(ird-1).x, self.point(ird).x]
+            )
+            y = np.interp(
+                z,
+                [self.point(ird).z, self.point(ird - 1).z],
+                [self.point(ird).y, self.point(ird - 1).y]
+            )
+            ptY = PointXYZ(x, y, z)
+        else:
+            ptY = self.point(self.number_points - 1)
+
+        return ptX, ptY

src/Model/Geometry/Reach.py

@@ -36,13 +36,14 @@ from Model.Except import FileFormatError, exception_message_box
 
 logger = logging.getLogger()
 
+
 class Reach(SQLSubModel):
     _sub_classes = [
         ProfileXYZ,
     ]
 
     def __init__(self, status=None, parent=None):
-        self.id = parent.id
+        self.id = parent.id if parent is not None else 0
         self._status = status
         self._parent = parent
         self._profiles: List[Profile] = []
@@ -51,36 +52,37 @@ class Reach(SQLSubModel):
         self._guidelines = {}
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return cls._update_submodel(execute, version)
 
     @classmethod
-    def _sql_load(cls, execute, data = None):
+    def _db_load(cls, execute, data=None):
-        new = cls(status = data["status"], parent = data["parent"])
+        new = cls(status=data["status"], parent=data["reach"])
 
-        new._profiles = ProfileXYZ._sql_load(
+        new._profiles = ProfileXYZ._db_load(
             execute,
             data=data
         )
 
         return new
 
-    def _sql_save(self, execute, data = None):
+    def _db_save(self, execute, data=None):
+        profiles = self.profiles
+
         # Delete old data
         execute(f"DELETE FROM geometry_profileXYZ WHERE reach = {self.id}")
-        # execute(f"DELETE FROM geometry_pointXYZ")
 
         if data is None:
             data = {}
 
         ind = 0
-        for profile in self._profiles:
+        for profile in profiles:
             data["ind"] = ind
-            profile._sql_save(execute, data)
+            profile._db_save(execute, data)
             ind += 1
 
         return True
@@ -94,26 +96,53 @@ class Reach(SQLSubModel):
         Returns:
             The profile at index i
         """
-        if i < len(self._profiles):
+        if i < len(self.profiles):
-            return self._profiles[i]
+            return self.profiles[i]
 
         return None
 
     @property
     def name(self):
-        if self._parent == None:
+        if self._parent is None:
             return ""
 
         return self._parent.name
 
+    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}")
+        return list(
+            map(
+                lambda p: p[1],
+                sorted(
+                    self._profiles,
+                    key=lambda p: p[0]
+                )
+            )
+        )
+
+    def __len__(self):
+        if not isinstance(self._profiles, list):
+            self._profiles = self._get_profiles_list()
+
+        return len(self._profiles)
+
     @property
     def profiles(self):
-        return self._profiles.copy()
+        if not isinstance(self._profiles, list):
+            self._profiles = self._get_profiles_list()
+
+        return self._profiles
+
+    @profiles.setter
+    def profiles(self, profiles):
+        self._profiles = profiles
 
     def get_profiles_from_kp(self, kp):
         return list(
             filter(
-                lambda p: p.kp == kp, self._profiles
+                lambda p: p.kp == kp, self.profiles
             )
         )
 
@@ -123,14 +152,14 @@ class Reach(SQLSubModel):
         Returns:
             Number of profiles
         """
-        return len(self._profiles)
+        return len(self.profiles)
 
     def get_geometry(self) -> List[Profile]:
         """
         Returns:
             The profiles list.
         """
-        return self._profiles
+        return self.profiles
 
     def _update_profile_numbers(self):
         """Update profiles index
@@ -152,7 +181,7 @@ class Reach(SQLSubModel):
         """
         profile = ProfileXYZ(reach=self, status=self._status)
 
-        self._profiles.insert(index, profile)
+        self.profiles.insert(index, profile)
         self._update_profile_numbers()
 
         self._status.modified()
@@ -168,11 +197,10 @@ class Reach(SQLSubModel):
         Returns:
             Nothing.
         """
-        self._profiles.insert(index, profile)
+        self.profiles.insert(index, profile)
         self._update_profile_numbers()
         self._status.modified()
 
-
     def delete(self, indexes):
         """Delete some elements in profile list
 
@@ -219,12 +247,11 @@ class Reach(SQLSubModel):
         self._update_profile_numbers()
         self._status.modified()
 
-
     def move_up_profile(self, index: int):
         if index < len(self.profiles):
             next = index - 1
 
-            p = self._profiles
+            p = self.profiles
             p[index], p[next] = p[next], p[index]
             self._status.modified()
 
@@ -232,7 +259,7 @@ class Reach(SQLSubModel):
         if index >= 0:
             prev = index + 1
 
-            p = self._profiles
+            p = self.profiles
             p[index], p[prev] = p[prev], p[index]
             self._status.modified()
 
@@ -275,7 +302,6 @@ class Reach(SQLSubModel):
     def get_kp_max(self):
         return max(self.get_kp())
 
-
     # Sediment Layers
 
     def get_sl(self):
@@ -324,12 +350,12 @@ class Reach(SQLSubModel):
         for guide in guide_set:
             self._guidelines[guide] = flatten(
                 map(
-                    lambda l: list(
+                    lambda lst: list(
                         # Filter point with name (we assume we have
                         # only one point by profile)
                         filter(
                             lambda p: p.name == guide,
-                            l
+                            lst
                         )
                     ),
                     named_points
@@ -344,7 +370,7 @@ class Reach(SQLSubModel):
             Tuple of complete and incomplete guidelines name.
         """
         # Get all point contains into a guideline
-        named_points = [profile.named_points() for profile in self._profiles]
+        named_points = [profile.named_points() for profile in self.profiles]
         points_name = list(
             map(
                 lambda lst: list(map(lambda p: p.name, lst)),
@@ -364,7 +390,9 @@ class Reach(SQLSubModel):
             reduce(
                 lambda acc, h: acc + h,
                 map(
-                    lambda l: list(set(l).symmetric_difference(guide_set)),
+                    lambda lst: list(
+                        set(lst).symmetric_difference(guide_set)
+                    ),
                     points_name
                 ),
                 []
@@ -414,13 +442,12 @@ class Reach(SQLSubModel):
     def get_guidelines_z(self):
         return self._map_guidelines_points(lambda p: p.z)
 
-
     # Sort
 
     @timer
     def sort(self, is_reversed: bool = False):
-        self._profiles = sorted(
+        self.profiles = sorted(
-            self._profiles,
+            self.profiles,
             key=lambda profile: profile.kp,
             reverse=is_reversed
         )
@@ -428,10 +455,10 @@ class Reach(SQLSubModel):
 
     @timer
     def sort_with_indexes(self, indexes: list):
-        if len(self._profiles) != len(indexes):
+        if len(self.profiles) != len(indexes):
             logger.critical("Indexes list do not correspond to profile list")
 
-        self._profiles = list(
+        self.profiles = list(
             map(
                 lambda x: x[1],
                 sorted(
@@ -449,7 +476,8 @@ class Reach(SQLSubModel):
         """Import a geometry from file (.ST or .st)
 
         Args:
-            file_path_name: The absolute path of geometry file (.ST or .st) to import.
+            file_path_name: The absolute path of geometry file (.ST or .st)
+                            to import.
 
         Returns:
             Nothing.
@@ -459,7 +487,8 @@ 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"]
+            profile_header = ["num", "code1",
+                              "code2", "nb_point", "kp", "name"]
 
             if list_profile and list_header:
                 for ind, profile in enumerate(list_profile):
@@ -471,7 +500,7 @@ class Reach(SQLSubModel):
                         **d, reach=self, status=self._status
                     )
                     prof.import_points(profile)
-                    self._profiles.append(prof)
+                    self.profiles.append(prof)
                     self._update_profile_numbers()
 
                 self._status.modified()
@@ -535,8 +564,8 @@ class Reach(SQLSubModel):
     # TODO: Move this function to model reach
     def export_reach(self, filename):
         with open(f"{filename}", "w") as file_st:
-            for index in range(len(self._profiles)):
+            for index in range(len(self.profiles)):
-                profile = self._profiles[index]
+                profile = self.profiles[index]
 
                 for v in profile.header:
                     file_st.write(f"{v:>6}")
@@ -807,3 +836,103 @@ class Reach(SQLSubModel):
             profiles[-1].import_points(points)
 
         return profiles
+
+    def get_incline(self):
+        first = self.profile(0)
+        last = self.profile(len(self) - 1)
+
+        z_first = first.z_min()
+        kp_first = first.kp
+
+        z_last = last.z_min()
+        kp_last = last.kp
+
+        return (
+            (z_last - z_first)
+            /
+            (kp_last - kp_first)
+        )
+
+    def get_incline_mean(self):
+        profiles = self.profiles
+        previous = profiles[0]
+
+        incline_acc = 0
+
+        for profile in profiles[1:]:
+            z_first = previous.z_min()
+            kp_first = previous.kp
+
+            z_last = profile.z_min()
+            kp_last = profile.kp
+
+            incline_acc += (
+                (z_last - z_first)
+                /
+                (kp_last - kp_first)
+            )
+
+            previous = profile
+
+        return (incline_acc / (len(profiles) - 1))
+
+    def get_incline_median(self):
+        profiles = self.profiles
+        previous = profiles[0]
+
+        incline_acc = []
+
+        for profile in profiles[1:]:
+            z_first = previous.z_min()
+            kp_first = previous.kp
+
+            z_last = profile.z_min()
+            kp_last = profile.kp
+
+            incline_acc += [
+                (z_last - z_first)
+                /
+                (kp_last - kp_first)
+            ]
+
+            previous = profile
+
+        incline_acc.sort()
+        return incline_acc[round(len(profiles)/2)]
+
+    def get_incline_median_mean(self):
+        profiles = self.profiles
+        previous = profiles[0]
+
+        incline_acc = []
+
+        for profile in profiles[1:]:
+            z_first = previous.z_min()
+            kp_first = previous.kp
+
+            z_last = profile.z_min()
+            kp_last = profile.kp
+
+            incline_acc += [
+                (z_last - z_first)
+                /
+                (kp_last - kp_first)
+            ]
+
+            previous = profile
+
+        incline_acc.sort()
+
+        marge = round(len(incline_acc) * 0.1)
+        incline_set = incline_acc[marge:-marge]
+
+        logger.debug(f"+{incline_acc}")
+        logger.debug(f"-{incline_set}")
+
+        return (
+            reduce(
+                lambda acc, x: acc + x,
+                incline_set,
+                0.0
+            ) / (len(incline_set))
+        )

src/Model/Geometry/Vector_1d.py

@@ -19,6 +19,7 @@
 import numpy as np
 from Model.Geometry.PointXYZ import PointXYZ
 
+
 class Vector1d:
     def __init__(self, a: PointXYZ, b: PointXYZ):
         self.A = a

src/Model/HydraulicStructures/Basic/HydraulicStructures.py

@@ -0,0 +1,191 @@
+# HydraulicStructures.py -- Pamhyr
+# Copyright (C) 2023  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import logging
+
+from tools import trace, timer
+
+from Model.Tools.PamhyrDB import SQLSubModel
+from Model.Except import NotImplementedMethodeError
+
+from Model.HydraulicStructures.Basic.Value import (
+    BHSValue
+)
+
+logger = logging.getLogger()
+
+
+class BasicHS(SQLSubModel):
+    _sub_classes = [
+        BHSValue,
+    ]
+    _id_cnt = 0
+
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None):
+        super(BasicHS, self).__init__()
+
+        self._status = status
+
+        if id == -1:
+            self.id = BasicHS._id_cnt
+        else:
+            self.id = id
+
+        self._name = name
+        self._type = ""
+        self._enabled = True
+        self._data = []
+
+        BasicHS._id_cnt = max(BasicHS._id_cnt + 1, self.id)
+
+    @classmethod
+    def _db_create(cls, execute):
+        execute("""
+          CREATE TABLE hydraulic_structures_basic(
+            id INTEGER NOT NULL PRIMARY KEY,
+            name TEXT NOT NULL,
+            type TEXT NOT NULL,
+            enabled BOOLEAN NOT NULL,
+            hs INTEGER,
+            FOREIGN KEY(hs) REFERENCES hydraulic_structures(id)
+          )
+        """)
+
+        return cls._create_submodel(execute)
+
+    @classmethod
+    def _db_update(cls, execute, version):
+        major, minor, release = version.strip().split(".")
+        if major == minor == "0":
+            if int(release) < 6:
+                cls._db_create(execute)
+
+        return True
+
+    @classmethod
+    def _get_ctor_from_type(cls, t):
+        from Model.HydraulicStructures.Basic.Types import (
+            BHS_types, NotDefined,
+        )
+
+        res = NotDefined
+
+        if t in BHS_types.keys():
+            res = BHS_types[t]
+
+        return res
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = []
+
+        table = execute(
+            "SELECT id, name, type, enabled, hs " +
+            "FROM hydraulic_structures_basic " +
+            f"WHERE hs = {data['hs_id']} "
+        )
+
+        for row in table:
+            bhs_id = row[0]
+            name = row[1]
+            type = row[2]
+            enabled = (row[3] == 1)
+            hs_id = row[4]
+
+            ctor = cls._get_ctor_from_type(type)
+            bhs = ctor(
+                id=bhs_id,
+                name=name,
+                status=data['status']
+            )
+
+            bhs.enabled = enabled
+
+            data['bhs_id'] = bhs_id
+            bhs._data = BHSValue._db_load(
+                execute, data
+            )
+
+            new.append(bhs)
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        hs_id = data['hs_id']
+
+        sql = (
+            "INSERT INTO " +
+            "hydraulic_structures_basic(id, name, type, enabled, hs) " +
+            "VALUES (" +
+            f"{self.id}, " +
+            f"'{self._db_format(self._name)}', " +
+            f"'{self._db_format(self._type)}', " +
+            f"{self._db_format(self.enabled)}, " +
+            f"{hs_id} " +
+            ")"
+        )
+        execute(sql)
+
+        data['bhs_id'] = self.id
+        execute(
+            "DELETE FROM hydraulic_structures_basic_value " +
+            f"WHERE bhs = {self.id}"
+        )
+
+        for values in self._data:
+            values._db_save(execute, data)
+
+        return True
+
+    def __len__(self):
+        return len(self._data)
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, name):
+        self._name = name
+        self._status.modified()
+
+    @property
+    def type(self):
+        return self._type
+
+    @type.setter
+    def type(self, type):
+        self._type = type
+        self._status.modified()
+
+    @property
+    def enabled(self):
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, enabled):
+        self._enabled = enabled
+        self._status.modified()
+
+    @property
+    def parameters(self):
+        return self._data
+
+    def convert(self, new_type):
+        return new_type(id=self.id, name=self.name, status=self._status)

src/Model/HydraulicStructures/Basic/Types.py

@@ -0,0 +1,228 @@
+# Types.py -- Pamhyr
+# Copyright (C) 2023  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 Model.HydraulicStructures.Basic.HydraulicStructures import (
+    BasicHS
+)
+
+from Model.HydraulicStructures.Basic.Value import (
+    BHSValue
+)
+
+
+class NotDefined(BasicHS):
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None):
+        super(NotDefined, self).__init__(
+            id=id, name=name,
+            status=status
+        )
+
+        self._type = "ND"
+        self._data = []
+
+
+class SeuilDeversoir(BasicHS):
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None):
+        super(SeuilDeversoir, self).__init__(
+            id=id, name=name,
+            status=status
+        )
+
+        self._type = "S1"
+        self._data = [
+            BHSValue("Largeur", float, 1.0, status=status),
+            BHSValue("Cote", float, 1.0, status=status),
+            BHSValue("Coefficient de debit", float, 0.4, status=status),
+        ]
+
+
+class SeuilTrapezoidal(BasicHS):
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None):
+        super(SeuilTrapezoidal, self).__init__(
+            id=id, name=name,
+            status=status
+        )
+
+        self._type = "S2"
+        self._data = [
+            BHSValue("Largeur", float, 1.0, status=status),
+            BHSValue("Cote", float, 1.0, status=status),
+            BHSValue("Cote de mise en charge", float, 9999.999, status=status),
+            BHSValue("Coefficient de debit", float, 0.4, status=status),
+            BHSValue("Tangeante du demi angle", float, 0.0, status=status),
+        ]
+
+
+class SeuilTriangulaire(BasicHS):
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None):
+        super(SeuilTriangulaire, self).__init__(
+            id=id, name=name,
+            status=status
+        )
+
+        self._type = "S3"
+        self._data = [
+            BHSValue("Cote", float, 1.0, status=status),
+            BHSValue("Cote de mise en charge", float, 9999.999, status=status),
+            BHSValue("Coefficient de debit", float, 0.4, status=status),
+            BHSValue("Tangeante du demi angle", float, 0.0, status=status),
+        ]
+
+
+class OrificeRectangulaire(BasicHS):
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None):
+        super(OrificeRectangulaire, self).__init__(
+            id=id, name=name,
+            status=status
+        )
+
+        self._type = "OR"
+        self._data = [
+            BHSValue("Largeur", float, 0.0, status=status),
+            BHSValue("Cote", float, 0.0, status=status),
+            BHSValue("Cote de mise en charge", float, 9999.999,
+                     status=status),
+            BHSValue("Coefficient de debit", float, 0.4, status=status),
+            BHSValue("Cote de mise en charge maximale", float, 9999.999,
+                     status=status),
+        ]
+
+
+class OrificeCirculaire(BasicHS):
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None):
+        super(OrificeCirculaire, self).__init__(
+            id=id, name=name,
+            status=status
+        )
+
+        self._type = "OC"
+        self._data = [
+            BHSValue("Diametre", float, 0.0, status=status),
+            BHSValue("Cote", float, 0.0, status=status),
+            BHSValue("hauteur envasement", float, 0.0, status=status),
+            BHSValue("Coefficient de debit", float, 0.4, status=status),
+        ]
+
+
+# class OrificeVoute(BasicHS):
+#     def __init__(self, id: int = -1, name: str = "",
+#                  status=None):
+#         super(OrificeVoute, self).__init__(
+#             id=id, name=name,
+#             status=status
+#         )
+
+#         self._type = "OV"
+#         self._data = [
+#             BHSValue("Cote", float, 1.0, status=status),
+#             BHSValue("Largeur", float, 1.0, status=status),
+#             BHSValue("Haut de la voute", float, 0.0, status=status),
+#             BHSValue("Bas de la voute", float, 0.0, status=status),
+#             BHSValue("Coefficient de debit", float, 0.4, status=status),
+#         ]
+
+
+class VanneRectangulaire(BasicHS):
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None):
+        super(VanneRectangulaire, self).__init__(
+            id=id, name=name,
+            status=status
+        )
+
+        self._type = "V1"
+        self._data = [
+            BHSValue("Largeur", float, 1.0, status=status),
+            BHSValue("Cote", float, 0.0, status=status),
+            BHSValue("Coefficient de debit", float, 0.4, status=status),
+            BHSValue("Ouverture", float, 1.0, status=status),
+            BHSValue("Ouverture maximale", float, 1.0, status=status),
+        ]
+
+
+class VanneRectangulaireSimplifiee(BasicHS):
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None):
+        super(VanneRectangulaireSimplifiee, self).__init__(
+            id=id, name=name,
+            status=status
+        )
+
+        self._type = "V2"
+        self._data = [
+            BHSValue("Largeur", float, 1.0, status=status),
+            BHSValue("Cote", float, 0.0, status=status),
+            BHSValue("Coefficient de debit", float, 0.4, status=status),
+            BHSValue("Ouverture", float, 1.0, status=status),
+            BHSValue("Ouverture maximale", float, 1.0, status=status),
+        ]
+
+
+class Borda(BasicHS):
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None):
+        super(Borda, self).__init__(
+            id=id, name=name,
+            status=status
+        )
+
+        self._type = "BO"
+        self._data = [
+            BHSValue("Pas espace", float, 0.1, status=status),
+            BHSValue("Seuil", float, 0.15, status=status),
+            BHSValue("Coefficient", float, 0.4, status=status),
+        ]
+
+
+class UserDefined(BasicHS):
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None):
+        super(UserDefined, self).__init__(
+            id=id, name=name,
+            status=status
+        )
+
+        self._type = "UD"
+        self._data = [
+            BHSValue("Parameter 1", float, 0.0, status=status),
+            BHSValue("Parameter 2", float, 0.0, status=status),
+            BHSValue("Parameter 3", float, 0.0, status=status),
+            BHSValue("Parameter 4", float, 0.0, status=status),
+            BHSValue("Parameter 5", float, 0.0, status=status),
+        ]
+
+
+BHS_types = {
+    "ND": NotDefined,
+    "S1": SeuilDeversoir,
+    "S2": SeuilTrapezoidal,
+    "S3": SeuilTriangulaire,
+    "OR": OrificeRectangulaire,
+    "OC": OrificeCirculaire,
+    # "OV": OrificeVoute,
+    "V1": VanneRectangulaire,
+    "V2": VanneRectangulaireSimplifiee,
+    "BO": Borda,
+    "UD": UserDefined
+}

src/Model/HydraulicStructures/Basic/Value.py

@@ -0,0 +1,145 @@
+# Value.py -- Pamhyr
+# Copyright (C) 2023  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 Model.Tools.PamhyrDB import SQLSubModel
+
+
+class BHSValue(SQLSubModel):
+    _sub_classes = []
+    _id_cnt = 0
+
+    def __init__(self, name: str = "", type=float, value=0.0,
+                 status=None):
+        super(BHSValue, self).__init__()
+
+        self._status = status
+
+        self._name = name
+        self._type = type
+        self._value = type(value)
+
+    @classmethod
+    def _db_create(cls, execute):
+        execute("""
+          CREATE TABLE hydraulic_structures_basic_value(
+            id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL,
+            type TEXT NOT NULL,
+            value TEXT NOT NULL,
+            bhs INTEGER,
+            FOREIGN KEY(bhs) REFERENCES hydraulic_structures_basic(id)
+          )
+        """)
+
+        return cls._create_submodel(execute)
+
+    @classmethod
+    def _db_update(cls, execute, version):
+        major, minor, release = version.strip().split(".")
+        if major == minor == "0":
+            if int(release) < 6:
+                cls._db_create(execute)
+
+        return True
+
+    @classmethod
+    def _str_to_type(cls, type):
+        res = str
+
+        if type == "float":
+            res = float
+        elif type == "int":
+            res = int
+        elif type == "bool":
+            res = bool
+
+        return res
+
+    @classmethod
+    def _type_to_str(cls, type):
+        res = "str"
+
+        if type == float:
+            res = "float"
+        elif type == int:
+            res = "int"
+        elif type == bool:
+            res = "bool"
+
+        return res
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = []
+        bhs_id = data["bhs_id"]
+
+        table = execute(
+            "SELECT name, type, value " +
+            "FROM hydraulic_structures_basic_value " +
+            f"WHERE bhs = '{bhs_id}'"
+        )
+
+        for row in table:
+            name = row[0]
+            type = cls._str_to_type(row[1])
+            value = row[2]
+
+            val = cls(
+                name=name,
+                type=type,
+                value=value,
+                status=data['status']
+            )
+
+            new.append(val)
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        bhs_id = data["bhs_id"]
+
+        sql = (
+            "INSERT INTO " +
+            "hydraulic_structures_basic_value(name, type, value, bhs) " +
+            "VALUES (" +
+            f"'{self._db_format(self._name)}', " +
+            f"'{self._db_format(self._type_to_str(self._type))}', " +
+            f"'{self._db_format(self._value)}', " +
+            f"{bhs_id}" +
+            ")"
+        )
+        execute(sql)
+
+        return True
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def type(self):
+        return self._type
+
+    @property
+    def value(self):
+        return self._value
+
+    @value.setter
+    def value(self, value):
+        self._value = self._type(value)
+        self._status.modified()

src/Model/HydraulicStructures/HydraulicStructures.py

@@ -0,0 +1,285 @@
+# HydraulicStructures.py -- Pamhyr
+# Copyright (C) 2023  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import logging
+from functools import reduce
+
+from tools import trace, timer, old_pamhyr_date_to_timestamp
+
+from Model.Tools.PamhyrDB import SQLSubModel
+from Model.Except import NotImplementedMethodeError
+
+from Model.HydraulicStructures.Basic.HydraulicStructures import BasicHS
+from Model.HydraulicStructures.Basic.Types import (
+    NotDefined,
+)
+
+logger = logging.getLogger()
+
+
+class HydraulicStructure(SQLSubModel):
+    _sub_classes = [
+        BasicHS,
+    ]
+    _id_cnt = 0
+
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None):
+        super(HydraulicStructure, self).__init__()
+
+        self._status = status
+
+        if id == -1:
+            self.id = HydraulicStructure._id_cnt
+        else:
+            self.id = id
+
+        self._name = name
+        self._input_kp = None
+        self._output_kp = None
+        self._input_reach = None
+        self._output_reach = None
+        self._enabled = True
+        self._data = []
+
+        HydraulicStructure._id_cnt = max(
+            HydraulicStructure._id_cnt + 1,
+            self.id
+        )
+
+    @classmethod
+    def _db_create(cls, execute):
+        execute("""
+          CREATE TABLE hydraulic_structures(
+            id INTEGER NOT NULL PRIMARY KEY,
+            name TEXT NOT NULL,
+            enabled BOOLEAN NOT NULL,
+            input_kp REAL NOT NULL,
+            output_kp REAL NOT NULL,
+            input_reach INTEGER,
+            output_reach INTEGER,
+            FOREIGN KEY(input_reach) REFERENCES river_reach(id),
+            FOREIGN KEY(output_reach) REFERENCES river_reach(id)
+          )
+        """)
+
+        return cls._create_submodel(execute)
+
+    @classmethod
+    def _db_update(cls, execute, version):
+        major, minor, release = version.strip().split(".")
+        if major == minor == "0":
+            if int(release) < 6:
+                cls._db_create(execute)
+
+        return True
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = []
+
+        table = execute(
+            "SELECT id, name, enabled, " +
+            "input_kp, output_kp, " +
+            "input_reach, output_reach " +
+            "FROM hydraulic_structures "
+        )
+
+        for row in table:
+            it = iter(row)
+
+            hs_id = next(it)
+            name = next(it)
+            enabled = (next(it) == 1)
+            input_kp = next(it)
+            output_kp = next(it)
+            input_reach_id = next(it)
+            output_reach_id = next(it)
+
+            hs = cls(
+                id=hs_id,
+                name=name,
+                status=data['status']
+            )
+
+            hs.enabled = enabled
+            hs.input_kp = input_kp if input_kp != -1 else None
+            hs.output_kp = output_kp if output_kp != -1 else None
+
+            hs.input_reach, hs.output_reach = reduce(
+                lambda acc, n: (
+                    n if n.id == input_reach_id else acc[0],
+                    n if n.id == output_reach_id else acc[1]
+                ),
+                data["edges"],
+                [None, None]
+            )
+
+            data['hs_id'] = hs_id
+            hs._data = BasicHS._db_load(execute, data)
+
+            new.append(hs)
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        execute(f"DELETE FROM hydraulic_structures WHERE id = {self.id}")
+
+        input_reach_id = -1
+        if self._input_reach is not None:
+            input_reach_id = self._input_reach.id
+
+        output_reach_id = -1
+        if self._output_reach is not None:
+            output_reach_id = self._output_reach.id
+
+        input_kp = -1
+        if self.input_kp is not None:
+            input_kp = self.input_kp
+
+        output_kp = -1
+        if self.output_kp is not None:
+            output_kp = self.output_kp
+
+        sql = (
+            "INSERT INTO " +
+            "hydraulic_structures(" +
+            "  id, name, enabled, input_kp, output_kp, " +
+            "  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_reach_id}, {output_reach_id}" +
+            ")"
+        )
+        execute(sql)
+
+        data['hs_id'] = self.id
+        execute(
+            "DELETE FROM hydraulic_structures_basic " +
+            f"WHERE hs = {self.id}"
+        )
+
+        for basic in self._data:
+            basic._db_save(execute, data)
+
+        return True
+
+    def __len__(self):
+        return len(self._data)
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, name):
+        self._name = name
+        self._status.modified()
+
+    @property
+    def input_kp(self):
+        return self._input_kp
+
+    @input_kp.setter
+    def input_kp(self, input_kp):
+        self._input_kp = input_kp
+        self._status.modified()
+
+    @property
+    def output_kp(self):
+        return self._output_kp
+
+    @output_kp.setter
+    def output_kp(self, output_kp):
+        self._output_kp = output_kp
+        self._status.modified()
+
+    @property
+    def enabled(self):
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, enabled):
+        self._enabled = enabled
+        self._status.modified()
+
+    @property
+    def input_reach(self):
+        return self._input_reach
+
+    @input_reach.setter
+    def input_reach(self, input_reach):
+        self._input_reach = input_reach
+        self._status.modified()
+
+    @property
+    def output_reach(self):
+        return self._output_reach
+
+    @output_reach.setter
+    def output_reach(self, output_reach):
+        self._output_reach = output_reach
+        self._status.modified()
+
+    @property
+    def basic_structures(self):
+        return self._data.copy()
+
+    def basic_structure(self, index: int):
+        return self._data[index]
+
+    def add(self, index: int):
+        value = NotDefined(status=self._status)
+        self._data.insert(index, value)
+        self._status.modified()
+        return value
+
+    def insert(self, index: int, value: BasicHS):
+        self._data.insert(index, value)
+        self._status.modified()
+
+    def delete_i(self, indexes):
+        self._data = list(
+            map(
+                lambda e: e[1],
+                filter(
+                    lambda e: e[0] not in indexes,
+                    enumerate(self._data)
+                )
+            )
+        )
+        self._status.modified()
+
+    def delete(self, els):
+        self._data = list(
+            filter(
+                lambda e: e not in els,
+                self._data
+            )
+        )
+        self._status.modified()
+
+    def sort(self, _reverse=False, key=None):
+        if key is None:
+            self._data.sort(reverse=_reverse)
+        else:
+            self._data.sort(reverse=_reverse, key=key)
+        self._status.modified()

src/Model/HydraulicStructures/HydraulicStructuresList.py

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

src/Model/InitialConditions/InitialConditions.py

@@ -16,12 +16,17 @@
 
 # -*- coding: utf-8 -*-
 
+import logging
+
 from copy import copy, deepcopy
 from tools import trace, timer
 from functools import reduce
 
 from Model.Tools.PamhyrDB import SQLSubModel
 
+logger = logging.getLogger()
+
+
 class Data(SQLSubModel):
     def __init__(self, name: str = "",
                  comment: str = "", reach=None,
@@ -51,7 +56,7 @@ class Data(SQLSubModel):
             self._update_from_discharge()
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         execute("""
           CREATE TABLE initial_conditions(
             id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
@@ -69,11 +74,11 @@ class Data(SQLSubModel):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return cls._update_submodel(execute, version)
 
     @classmethod
-    def _sql_load(cls, execute, data = None):
+    def _db_load(cls, execute, data=None):
         id = data["reach"].id
         table = execute(
             "SELECT ind, name, comment, kp, discharge, height " +
@@ -108,15 +113,16 @@ class Data(SQLSubModel):
 
         return new
 
-    def _sql_save(self, execute, data = None):
+    def _db_save(self, execute, data=None):
         ind = data["ind"]
 
         execute(
             "INSERT INTO " +
-            "initial_conditions(ind, name, comment, kp, discharge, height, reach) " +
+            "initial_conditions(ind, name, comment, kp, " +
+            "discharge, height, reach) " +
             "VALUES (" +
-            f"{ind}, '{self._sql_format(self.name)}', " +
+            f"{ind}, '{self._db_format(self.name)}', " +
-            f"'{self._sql_format(self._comment)}', " +
+            f"'{self._db_format(self._comment)}', " +
             f"{self._kp}, {self._discharge}, {self._height}, " +
             f"{self._reach.id}" +
             ")"
@@ -124,7 +130,6 @@ class Data(SQLSubModel):
 
         return True
 
-
     def copy(self):
         new = Data(
             name=self.name,
@@ -173,7 +178,7 @@ class Data(SQLSubModel):
 
     def _update_from_kp(self):
         min = self._update_get_min()
-        self._elevation = min - self._height
+        self._elevation = min + self._height
 
     def _update_from_elevation(self):
         min = self._update_get_min()
@@ -225,37 +230,35 @@ class InitialConditions(SQLSubModel):
         self._data = []
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return cls._update_submodel(execute, version)
 
     @classmethod
-    def _sql_load(cls, execute, data = None):
+    def _db_load(cls, execute, data=None):
         new = cls(
             reach=data["reach"],
             status=data["status"]
         )
 
-        new._data = Data._sql_load(
+        new._data = Data._db_load(
             execute,
             data=data
         )
 
-        if new._data is None:
+        if new._data is not None:
-            return None
-
             return new
 
-    def _sql_save(self, execute, data = None):
+    def _db_save(self, execute, data=None):
         ok = True
 
         ind = 0
         for d in self._data:
             data["ind"] = ind
-            ok &= d._sql_save(execute, data)
+            ok &= d._db_save(execute, data)
             ind += 1
 
         return ok
@@ -321,7 +324,6 @@ class InitialConditions(SQLSubModel):
         self._data.sort(reverse=reverse, key=key)
         self._status.modified()
 
-
     def _data_get(self, key):
         return list(
             map(
@@ -357,25 +359,90 @@ class InitialConditions(SQLSubModel):
     def generate_growing_constante_height(self, height: float):
         self._data = []
 
-        profiles = self._reach.reach.profiles
+        profiles = self._reach.reach.profiles.copy()
         self._sort_by_z_and_kp(profiles)
 
-        prev = None
+        incline = self._reach.reach.get_incline_median_mean()
-        for profile in profiles:
+        logger.debug(f"incline = {incline}")
-            new = Data(reach = self._reach, status = self._status)
-            new["kp"] = profile.kp
 
-            if prev is None:
+        previous_elevation = -99999.99
-                new["elevation"] = profile.z_min() + height
+        for profile in profiles:
-            else:
+            width = profile.width_approximation()
-                new["elevation"] = max(
+            strickler = 25
-                    profile.z_min() + height,
+            discharge = (
-                    prev["elevation"]
+                ((width * 0.8)
+                 * strickler
+                 * (height ** (5/3))
+                 * (abs(incline) ** (0.5)))
             )
 
-            self._data.append(new)
+            elevation = max(
-            prev = new
+                profile.z_min() + height,
+                previous_elevation
+            )
 
+            logger.debug(f"({profile.kp}):")
+            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["discharge"] = discharge
+
+            new["elevation"] = elevation
+
+            self._data.append(new)
+            previous_elevation = elevation
+
+        self._generate_resort_data(profiles)
+
+    def generate_discharge(self, discharge: float):
+        self._data = []
+
+        self._generate_height_estimation_from_discharge(
+            discharge
+        )
+
+    def _generate_height_estimation_from_discharge(self, discharge: float):
+        profiles = self._reach.reach.profiles.copy()
+        self._sort_by_z_and_kp(profiles)
+
+        previous_elevation = -99999.99
+
+        incline = self._reach.reach.get_incline_median_mean()
+        logger.debug(f"incline = {incline}")
+
+        for profile in profiles:
+            width = profile.width_approximation()
+            strickler = 25
+            height = (
+                discharge
+                /
+                ((width * 0.8) * strickler * (abs(incline) ** (0.5)))
+            ) ** (0.6)
+
+            elevation = max(
+                profile.z_min() + height,
+                previous_elevation
+            )
+
+            logger.debug(f"({profile.kp}):")
+            logger.debug(f"  width  = {width}")
+            logger.debug(f"  strickler = {strickler}")
+            logger.debug(f"  hieght = {height}")
+
+            new = Data(reach=self._reach, status=self._status)
+            new["kp"] = profile.kp
+            new["discharge"] = discharge
+            new["elevation"] = elevation
+
+            previous_elevation = elevation
+            self._data.append(new)
+
+        self._generate_resort_data(profiles)
+
+    def _generate_resort_data(self, profiles):
         is_reverse = False
         if profiles[0].kp > profiles[-1].kp:
             is_reverse = True
@@ -384,13 +451,3 @@ class InitialConditions(SQLSubModel):
             reverse=not is_reverse,
             key=lambda d: d['kp']
         )
-
-    def generate_discharge(self, discharge:float):
-        self._new = []
-
-        for d in self._data:
-            n = d.copy()
-            n['discharge'] = discharge
-            self._new.append(n)
-
-        self._data = self._new

src/Model/InitialConditions/InitialConditionsDict.py

@@ -16,25 +16,31 @@
 
 # -*- coding: utf-8 -*-
 
+import types
+import logging
+
 from copy import copy
 from tools import trace, timer
 
 from Model.Tools.PamhyrDict import PamhyrModelDict
 from Model.InitialConditions.InitialConditions import InitialConditions
 
+logger = logging.getLogger()
+
+
 class InitialConditionsDict(PamhyrModelDict):
     _sub_classes = [
         InitialConditions,
     ]
 
     @classmethod
-    def _sql_load(cls, execute, data = None):
+    def _db_load(cls, execute, data=None):
         new = cls(status=data["status"])
 
         for reach in data["edges"]:
             data["reach"] = reach
 
-            ic = InitialConditions._sql_load(
+            ic = InitialConditions._db_load(
                 execute,
                 data=data
             )
@@ -44,19 +50,39 @@ class InitialConditionsDict(PamhyrModelDict):
 
         return new
 
-    def _sql_save(self, execute, data = None):
+    def _db_save(self, execute, data=None):
         ok = True
         if data is None:
             data = {}
 
-        execute("DELETE FROM initial_conditions")
+        ics = self._dict
-
+        for reach in ics:
-        for reach in self._dict:
             data["reach"] = reach
-            ok &= self._dict[reach]._sql_save(execute, data)
+            v = self._dict[reach]
+            if isinstance(v, types.GeneratorType):
+                self._dict[reach] = list(v)[0]
+
+            execute(
+                "DELETE FROM initial_conditions " +
+                f"WHERE reach = '{reach.id}'"
+            )
+
+            ok &= self._dict[reach]._db_save(execute, data)
 
         return ok
 
+    def get(self, key):
+        if key in self._dict:
+            v = self._dict[key]
+            if isinstance(v, types.GeneratorType):
+                self._dict[key] = list(v)[0]
+
+            return self._dict[key]
+
+        new = self.new(key)
+        self.set(key, new)
+        return new
+
     def new(self, reach):
         new = InitialConditions(reach=reach, status=self._status)
         self.set(reach, new)

src/Model/LateralContribution/LateralContribution.py

@@ -25,6 +25,7 @@ from Model.Except import NotImplementedMethodeError
 
 logger = logging.getLogger()
 
+
 class LateralContribution(SQLSubModel):
     _sub_classes = []
     _id_cnt = 0
@@ -39,7 +40,6 @@ class LateralContribution(SQLSubModel):
         else:
             self.id = id
 
-
         self._name = name
         self._type = ""
         self._edge = None
@@ -49,10 +49,11 @@ class LateralContribution(SQLSubModel):
         self._header = []
         self._types = [float, float]
 
-        LateralContribution._id_cnt = max(LateralContribution._id_cnt + 1, self.id)
+        LateralContribution._id_cnt = max(
+            LateralContribution._id_cnt + 1, self.id)
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         execute("""
           CREATE TABLE lateral_contribution(
             id INTEGER NOT NULL PRIMARY KEY,
@@ -80,7 +81,7 @@ class LateralContribution(SQLSubModel):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return True
 
     @classmethod
@@ -99,7 +100,7 @@ class LateralContribution(SQLSubModel):
         return res
 
     @classmethod
-    def _sql_load(cls, execute, data = None):
+    def _db_load(cls, execute, data=None):
         new = []
         tab = data["tab"]
 
@@ -141,7 +142,7 @@ class LateralContribution(SQLSubModel):
 
         return new
 
-    def _sql_save(self, execute, data = None):
+    def _db_save(self, execute, data=None):
         tab = data["tab"]
 
         execute(f"DELETE FROM lateral_contribution WHERE id = {self.id}")
@@ -153,10 +154,11 @@ class LateralContribution(SQLSubModel):
 
         sql = (
             "INSERT INTO " +
-            "lateral_contribution(id, name, type, tab, edge, begin_kp, end_kp) "+
+            "lateral_contribution(id, name, type, tab, " +
+            "edge, begin_kp, end_kp) " +
             "VALUES (" +
-            f"{self.id}, '{self._sql_format(self._name)}', " +
+            f"{self.id}, '{self._db_format(self._name)}', " +
-            f"'{self._sql_format(self._type)}', '{tab}', {edge}, " +
+            f"'{self._db_format(self._type)}', '{tab}', {edge}, " +
             f"{self._begin_kp}, {self._end_kp}" +
             ")"
         )
@@ -164,8 +166,8 @@ class LateralContribution(SQLSubModel):
 
         ind = 0
         for d in self._data:
-            data0 = self._sql_format(str(d[0]))
+            data0 = self._db_format(str(d[0]))
-            data1 = self._sql_format(str(d[1]))
+            data1 = self._db_format(str(d[1]))
 
             sql = (
                 "INSERT INTO " +
@@ -186,8 +188,13 @@ class LateralContribution(SQLSubModel):
 
     @classmethod
     def time_convert(cls, data):
-        if type(data) == str and data.count(":") == 3:
+        if type(data) is str:
+            if data.count(":") == 3:
                 return old_pamhyr_date_to_timestamp(data)
+            if data.count(":") == 2:
+                return old_pamhyr_date_to_timestamp("00:" + data)
+            if data.count(".") == 1:
+                return round(float(data))
 
         return int(data)
 
@@ -337,11 +344,10 @@ class LateralContribution(SQLSubModel):
         return self.data[index]
 
     def get_range(self, _range):
-        l = []
+        lst = []
         for r in _range:
-            l.append(r)
+            lst.append(r)
-        return l
+        return lst
-
 
     def _set_i_c_v(self, index, column, value):
         v = list(self._data[index])

src/Model/LateralContribution/LateralContributionList.py

@@ -27,6 +27,7 @@ from Model.LateralContribution.LateralContributionTypes import (
     NotDefined, LateralContrib, Rain, Evaporation,
 )
 
+
 class LateralContributionList(PamhyrModelListWithTab):
     _tabs_list = ["liquid", "solid", "suspenssion"]
     _sub_classes = [
@@ -34,7 +35,7 @@ class LateralContributionList(PamhyrModelListWithTab):
     ]
 
     @classmethod
-    def _sql_load(cls, execute, data = None):
+    def _db_load(cls, execute, data=None):
         new = cls(status=data['status'])
 
         if data is None:
@@ -42,13 +43,13 @@ class LateralContributionList(PamhyrModelListWithTab):
 
         for tab in new._tabs:
             data["tab"] = tab
-            new._tabs[tab] = LateralContribution._sql_load(
+            new._tabs[tab] = LateralContribution._db_load(
                 execute, data
             )
 
         return new
 
-    def _sql_save(self, execute, data = None):
+    def _db_save(self, execute, data=None):
         execute("DELETE FROM lateral_contribution")
 
         if data is None:
@@ -57,7 +58,7 @@ class LateralContributionList(PamhyrModelListWithTab):
         for tab in self._tabs:
             data["tab"] = tab
             for lc in self._tabs[tab]:
-                lc._sql_save(execute, data = data)
+                lc._db_save(execute, data=data)
 
         return True
 
@@ -70,16 +71,16 @@ class LateralContributionList(PamhyrModelListWithTab):
     def __copy__(self):
         new = LateralContributionList()
 
-        for l in self._tabs:
+        for lst in self._tabs:
-            new.tabs[l] = self._tabs[l].copy()
+            new.tabs[lst] = self._tabs[lst].copy()
 
         return new
 
     def __deepcopy__(self):
         new = LateralContributionList()
 
-        for l in self._tabs:
+        for lst in self._tabs:
-            new.tabs[l] = self._tabs[l].deepcopy()
+            new.tabs[lst] = self._tabs[lst].deepcopy()
 
         return new
 

src/Model/LateralContribution/LateralContributionTypes.py

@@ -32,6 +32,7 @@ class NotDefined(LateralContribution):
     def _default_0(self):
         return 0.0
 
+
 class LateralContrib(LateralContribution):
     def __init__(self, id: int = -1, name: str = "", status=None):
         super(LateralContrib, self).__init__(id=id, name=name, status=status)
@@ -44,6 +45,7 @@ class LateralContrib(LateralContribution):
     def compatibility(cls):
         return ["liquid"]
 
+
 class Rain(LateralContribution):
     def __init__(self, id: int = -1, name: str = "", status=None):
         super(Rain, self).__init__(id=id, name=name, status=status)
@@ -56,6 +58,7 @@ class Rain(LateralContribution):
     def compatibility(cls):
         return ["liquid"]
 
+
 class Evaporation(LateralContribution):
     def __init__(self, id: int = -1, name: str = "", status=None):
         super(Evaporation, self).__init__(id=id, name=name, status=status)

src/Model/Network/Edge.py

@@ -18,6 +18,7 @@
 
 from Model.Network.Node import Node
 
+
 class Edge(object):
     _id_cnt = 0
 
@@ -74,7 +75,10 @@ class Edge(object):
 
     @property
     def name(self):
-        return self._name if self._name != "" else f"{self.node1.name} -> {self.node2.name}"
+        name = self._name
+        if self._name == "":
+            name = f"{self.node1.name} -> {self.node2.name}"
+        return name
 
     def is_enable(self):
         return self._enable

src/Model/Network/Graph.py

@@ -21,6 +21,7 @@ from functools import reduce
 from Model.Network.Node import Node
 from Model.Network.Edge import Edge
 
+
 class Graph(object):
     def __init__(self, status=None):
         super(Graph, self).__init__()
@@ -151,7 +152,6 @@ class Graph(object):
         )
         return edge
 
-
     def _add_edge(self, edge):
         # This edge already exists ?
         if any(filter(lambda e: (e.node1 == edge.node1 and
@@ -212,3 +212,16 @@ class Graph(object):
 
     def is_enable_edge(self, edge):
         return edge._enable
+
+    # def get_edge_id(self, reach):
+    #    for i, e in enumerate(self.enable_edges):
+    #        if e.id == reach.id:
+    #            return i
+
+    def get_edge_id(self, reach):
+        return next(
+            filter(
+                lambda e: e[1].id == reach.id,
+                enumerate(self.enable_edges())
+            )
+        )[0]

src/Model/Network/Node.py

@@ -18,6 +18,7 @@
 
 from Model.Network.Point import Point
 
+
 class Node(object):
     _id_cnt = 0
 
@@ -73,7 +74,6 @@ class Node(object):
     def y(self):
         return self.pos.y
 
-
     def setPos(self, x, y):
         self.pos.x = x
         self.pos.y = y

src/Model/Reservoir/Reservoir.py

@@ -0,0 +1,272 @@
+# Reservoir.py -- Pamhyr
+# Copyright (C) 2023  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 Model.Tools.PamhyrDB import SQLSubModel
+
+logger = logging.getLogger()
+
+
+class Reservoir(SQLSubModel):
+    _sub_classes = []
+    _id_cnt = 0
+
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None):
+        super(Reservoir, self).__init__()
+
+        self._status = status
+
+        if id == -1:
+            self.id = Reservoir._id_cnt
+        else:
+            self.id = id
+
+        self._name = name
+        self._node = None
+        self._data = []
+
+        Reservoir._id_cnt = max(Reservoir._id_cnt + 1, self.id)
+
+    @classmethod
+    def _db_create(cls, execute):
+        execute("""
+          CREATE TABLE reservoir(
+            id INTEGER NOT NULL PRIMARY KEY,
+            name TEXT NOT NULL,
+            node INTEGER,
+            FOREIGN KEY(node) REFERENCES river_node(id)
+          )
+        """)
+
+        execute("""
+          CREATE TABLE reservoir_data(
+            id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+            ind INTEGER NOT NULL,
+            elevation REAL NOT NULL,
+            surface REAL NOT NULL,
+            reservoir INTEGER,
+            FOREIGN KEY(reservoir) REFERENCES reservoir(id)
+          )
+        """)
+
+        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) < 5:
+                cls._db_create(execute)
+
+        return True
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = []
+
+        table = execute(
+            "SELECT id, name, node " +
+            "FROM reservoir "
+        )
+
+        for row in table:
+            id = row[0]
+            name = row[1]
+            node_id = row[2]
+            new_reservoir = cls(id, name, status=data["status"])
+
+            new_reservoir._node = None
+            if node_id != -1:
+                new_reservoir._node = next(
+                    filter(
+                        lambda n: n.id == node_id, data["nodes"]
+                    )
+                )
+
+            new_data = []
+            table = execute(
+                "SELECT elevation, surface " +
+                "FROM reservoir_data " +
+                f"WHERE reservoir = {id} " +
+                "ORDER BY ind ASC"
+            )
+            for t in table:
+                new_data.append((t[0], t[1]))
+
+            new_reservoir._data = new_data
+
+            new.append(new_reservoir)
+
+        return new
+
+    def _db_save(self, execute, data=None):
+
+        execute(f"DELETE FROM reservoir WHERE id = {self.id}")
+        execute(f"DELETE FROM reservoir_data WHERE reservoir = {self.id}")
+
+        node_id = -1
+        if self._node is not None:
+            node_id = self._node.id
+
+        sql = (
+            "INSERT INTO " +
+            "reservoir(id, name, node) " +
+            "VALUES (" +
+            f"{self.id}, '{self._db_format(self._name)}', " +
+            f"{node_id}" +
+            ")"
+        )
+        execute(sql)
+
+        ind = 0
+        for d in self._data:
+            sql = (
+                "INSERT INTO " +
+                "reservoir_data(ind, elevation, surface, reservoir) " +
+                f"VALUES ({ind}, '{d[0]}', {d[1]}, {self.id})"
+            )
+            execute(sql)
+            ind += 1
+
+        return True
+
+    def __len__(self):
+        return len(self._data)
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, name):
+        self._name = name
+        self._status.modified()
+
+    @property
+    def node(self):
+        return self._node
+
+    @node.setter
+    def node(self, node):
+        self._node = node
+        self._status.modified()
+
+    def has_node(self):
+        return self._node is not None
+
+    @property
+    def data(self):
+        return self._data.copy()
+
+    @property
+    def _default_elevation(self):
+        return 0.0
+
+    @property
+    def _default_surface(self):
+        return 0.0
+
+    def is_define(self):
+        return len(self._data) != 0
+
+    def new_from_data(self, data):
+
+        try:
+            new_0 = float(data[0])
+            new_1 = float(data[1])
+        except Exception as e:
+            logger.error(e)
+            new_0 = None
+            new_1 = None
+
+        return (new_0, new_1)
+
+    def add(self, index: int):
+        value = (self._default_elevation, self._default_surface)
+        self._data.insert(index, value)
+        self._status.modified()
+        return value
+
+    def insert(self, index: int, value):
+        self._data.insert(index, value)
+        self._status.modified()
+
+    def delete_i(self, indexes):
+        self._data = list(
+            map(
+                lambda e: e[1],
+                filter(
+                    lambda e: e[0] not in indexes,
+                    enumerate(self.data)
+                )
+            )
+        )
+        self._status.modified()
+
+    def delete(self, els):
+        self._data = list(
+            filter(
+                lambda e: e not in els,
+                self.data
+            )
+        )
+        self._status.modified()
+
+    def sort(self, _reverse=False, key=None):
+        if key is None:
+            self._data.sort(reverse=_reverse)
+        else:
+            self._data.sort(reverse=_reverse, key=key)
+        self._status.modified()
+
+    def get_i(self, index):
+        return self.data[index]
+
+    def get_range(self, _range):
+        lst = []
+        for r in _range:
+            lst.append(r)
+        return lst
+
+    def _set_i_c_v(self, index, column, value):
+        v = list(self._data[index])
+        v[column] = value
+        self._data[index] = tuple(v)
+        self._status.modified()
+
+    def set_i_elevation(self, index: int, value):
+        self._set_i_c_v(index, 0, value)
+
+    def set_i_surface(self, index: int, value):
+        self._set_i_c_v(index, 1, value)
+
+    def move_up(self, index):
+        if index < len(self):
+            next = index - 1
+            d = self._data
+            d[index], d[next] = d[next], d[index]
+            self._status.modified()
+
+    def move_down(self, index):
+        if index >= 0:
+            prev = index + 1
+            d = self._data
+            d[index], d[prev] = d[prev], d[index]
+            self._status.modified()

src/Model/Reservoir/ReservoirList.py

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

src/Model/Results/Results.py

@@ -24,9 +24,15 @@ from Model.Results.River.River import River
 
 logger = logging.getLogger()
 
+
 class Results(object):
-    def __init__(self, study = None):
+    def __init__(self, study=None, solver=None,
+                 repertory="", name="0"):
         self._study = study
+        self._solver = solver
+        self._repertory = repertory
+        self._name = name
+
         self._river = River(self._study)
 
         self._meta_data = {
@@ -43,8 +49,19 @@ class Results(object):
     def river(self):
         return self._river
 
+    @property
+    def study(self):
+        return self._study
+
     def set(self, key, value):
         self._meta_data[key] = value
 
     def get(self, key):
         return self._meta_data[key]
+
+    def reload(self):
+        return self._solver.results(
+            self._study,
+            self._repertory,
+            qlog=None,
+        )

src/Model/Results/River/River.py

@@ -20,12 +20,16 @@ from datetime import datetime
 
 logger = logging.getLogger()
 
+
 class Profile(object):
     def __init__(self, profile, study):
         self._study = study
         self._profile = profile  # Source profile in the study
         self._data = {}  # Dict of dict {<ts>: {<key>: <value>, ...}, ...}
 
+    def __len__(self):
+        return len(self._data)
+
     @property
     def name(self):
         return self._profile.name
@@ -55,6 +59,7 @@ class Profile(object):
     def get_ts_key(self, timestamp, key):
         return self._data[timestamp][key]
 
+
 class Reach(object):
     def __init__(self, reach, study):
         self._study = study
@@ -66,6 +71,9 @@ class Reach(object):
             )
         )
 
+    def __len__(self):
+        return len(self._profiles)
+
     @property
     def name(self):
         return self._reach.name
@@ -84,6 +92,7 @@ class Reach(object):
     def set(self, profile_id, timestamp, key, data):
         self._profiles[profile_id].set(timestamp, key, data)
 
+
 class River(object):
     def __init__(self, study):
         self._study = study
@@ -91,6 +100,9 @@ class River(object):
         # Dict with timestamps as key
         self._reachs = []
 
+    def __len__(self):
+        return len(self._reachs)
+
     @property
     def reachs(self):
         return self._reachs.copy()

src/Model/River.py

@@ -28,15 +28,22 @@ from Model.Geometry.Profile import Profile
 from Model.Geometry.Reach import Reach
 
 from Model.BoundaryCondition.BoundaryConditionList import BoundaryConditionList
-from Model.LateralContribution.LateralContributionList import LateralContributionList
+from Model.LateralContribution.LateralContributionList import (
+    LateralContributionList
+)
 from Model.InitialConditions.InitialConditionsDict import InitialConditionsDict
 from Model.Stricklers.StricklersList import StricklersList
 from Model.Friction.FrictionList import FrictionList
 from Model.SolverParameters.SolverParametersList import SolverParametersList
 from Model.SedimentLayer.SedimentLayerList import SedimentLayerList
+from Model.Reservoir.ReservoirList import ReservoirList
+from Model.HydraulicStructures.HydraulicStructuresList import (
+    HydraulicStructureList,
+)
 
 from Solver.Solvers import solver_type_list
 
+
 class RiverNode(Node, SQLSubModel):
     _sub_classes = []
 
@@ -52,7 +59,7 @@ class RiverNode(Node, SQLSubModel):
         self._locker = None
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         execute("""
           CREATE TABLE river_node(
             id INTEGER NOT NULL PRIMARY KEY,
@@ -66,11 +73,11 @@ class RiverNode(Node, SQLSubModel):
         return True
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return True
 
     @classmethod
-    def _sql_load(cls, execute, data = None):
+    def _db_load(cls, execute, data=None):
         nodes = []
 
         table = execute("SELECT id, name, x, y FROM river_node")
@@ -82,10 +89,10 @@ class RiverNode(Node, SQLSubModel):
 
         return nodes
 
-    def _sql_save(self, execute, data = None):
+    def _db_save(self, execute, data=None):
         sql = (
             "INSERT OR REPLACE INTO river_node(id, name, x, y) VALUES (" +
-            f"{self.id}, '{self._sql_format(self.name)}', " +
+            f"{self.id}, '{self._db_format(self.name)}', " +
             f"{self.x}, {self.y}" +
             ")"
         )
@@ -122,7 +129,7 @@ class RiverReach(Edge, SQLSubModel):
         self._frictions = FrictionList(status=self._status)
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         execute("""
           CREATE TABLE river_reach(
             id INTEGER NOT NULL PRIMARY KEY,
@@ -139,17 +146,20 @@ class RiverReach(Edge, SQLSubModel):
         return True
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return cls._update_submodel(execute, version)
 
     @classmethod
-    def _sql_load(cls, execute, data = None):
+    def _db_load(cls, execute, data=None):
         reachs = []
 
         if data is None:
             data = {}
 
-        table = execute("SELECT id, name, enable, node1, node2 FROM river_reach")
+        table = execute(
+            "SELECT id, name, enable, node1, node2 FROM river_reach"
+        )
+
         for row in table:
             # Update id counter
             cls._id_cnt = max(cls._id_cnt, row[0])
@@ -164,23 +174,22 @@ class RiverReach(Edge, SQLSubModel):
             new = cls(id, name, node1, node2, status=data["status"])
             new.enable(enable=enable)
 
-            data["reach"] = id
+            data["reach"] = new
-            data["parent"] = new
-            new._reach = Reach._sql_load(execute, data)
 
-            new._frictions = FrictionList._sql_load(execute, data)
+            new._reach = Reach._db_load(execute, data)
+            new._frictions = FrictionList._db_load(execute, data)
 
             reachs.append(new)
 
         return reachs
 
-    def _sql_save(self, execute, data = None):
+    def _db_save(self, execute, data=None):
         sql = (
             "INSERT OR REPLACE INTO " +
             "river_reach(id, name, enable, node1, node2) " +
             "VALUES (" +
-            f"{self.id}, '{self._sql_format(self._name)}', " +
+            f"{self.id}, '{self._db_format(self._name)}', " +
-            f"{self._sql_format(self.is_enable())},"
+            f"{self._db_format(self.is_enable())},"
             f"{self.node1.id}, {self.node2.id}" +
             ")"
         )
@@ -202,6 +211,7 @@ class RiverReach(Edge, SQLSubModel):
     def frictions(self):
         return self._frictions
 
+
 class River(Graph, SQLSubModel):
     _sub_classes = [
         RiverNode,
@@ -212,6 +222,8 @@ class River(Graph, SQLSubModel):
         StricklersList,
         SolverParametersList,
         SedimentLayerList,
+        ReservoirList,
+        HydraulicStructureList,
     ]
 
     def __init__(self, status=None):
@@ -223,87 +235,105 @@ class River(Graph, SQLSubModel):
 
         self._current_reach = None
         self._boundary_condition = BoundaryConditionList(status=self._status)
-        self._lateral_contribution = LateralContributionList(status=self._status)
+        self._lateral_contribution = LateralContributionList(
+            status=self._status)
         self._initial_conditions = InitialConditionsDict(status=self._status)
         self._stricklers = StricklersList(status=self._status)
         self._parameters = {}
         self._sediment_layers = SedimentLayerList(status=self._status)
+        self._reservoir = ReservoirList(status=self._status)
+        self._hydraulic_structures = HydraulicStructureList(
+            status=self._status
+        )
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         cls._create_submodel(execute)
         return True
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         cls._update_submodel(execute, version)
         return True
 
     @classmethod
-    def _sql_load(cls, execute, data = None):
+    def _db_load(cls, execute, data=None):
         new = cls(data["status"])
 
         # Stricklers (Stricklers is load in first because it's needed
         # for reachs)
-        new._stricklers = StricklersList._sql_load(
+        new._stricklers = StricklersList._db_load(
             execute,
             data
         )
         data["stricklers"] = new._stricklers
 
-
         # Initial conditions
-        new._sediment_layers = SedimentLayerList._sql_load(
+        new._sediment_layers = SedimentLayerList._db_load(
             execute,
             data
         )
         data["sediment_layers_list"] = new._sediment_layers
 
         # Network
-        new._nodes = RiverNode._sql_load(
+        new._nodes = RiverNode._db_load(
             execute,
             data
         )
         data["nodes"] = new.nodes()
 
-        new._edges = RiverReach._sql_load(
+        new._edges = RiverReach._db_load(
             execute,
             data
         )
         data["edges"] = new.edges()
 
         # Boundary Condition
-        new._boundary_condition = BoundaryConditionList._sql_load(
+        new._boundary_condition = BoundaryConditionList._db_load(
             execute,
             data
         )
         # Lateral Contribution
-        new._lateral_contribution = LateralContributionList._sql_load(
+        new._lateral_contribution = LateralContributionList._db_load(
             execute,
             data
         )
 
         # Initial conditions
-        new._initial_conditions = InitialConditionsDict._sql_load(
+        new._initial_conditions = InitialConditionsDict._db_load(
+            execute,
+            data
+        )
+
+        # Reservoir
+        new._reservoir = ReservoirList._db_load(
+            execute,
+            data
+        )
+
+        # Hydraulic Structures
+        new._hydraulic_structures = HydraulicStructureList._db_load(
             execute,
             data
         )
 
         # Parameters
-        new._parameters = SolverParametersList._sql_load(
+        new._parameters = SolverParametersList._db_load(
             execute,
             data
         )
 
         return new
 
-    def _sql_save(self, execute, data = None):
+    def _db_save(self, execute, data=None):
         objs = (self._nodes + self._edges)
         objs.append(self._boundary_condition)
         objs.append(self._initial_conditions)
         objs.append(self._lateral_contribution)
         objs.append(self._sediment_layers)
         objs.append(self._stricklers)
+        objs.append(self._reservoir)
+        objs.append(self._hydraulic_structures)
 
         for solver in self._parameters:
             objs.append(self._parameters[solver])
@@ -344,6 +374,13 @@ class River(Graph, SQLSubModel):
 
         return ret[0]
 
+    @property
+    def reservoir(self):
+        return self._reservoir
+
+    @property
+    def hydraulic_structures(self):
+        return self._hydraulic_structures
 
     @property
     def parameters(self):
@@ -381,7 +418,7 @@ class River(Graph, SQLSubModel):
         has = len(self._sediment_layers) != 0
         has &= any(
             filter(
-                lambda p: p.sl != None,
+                lambda p: p.sl is not None,
                 flatten(
                     map(lambda e: e.reach.profiles, self.edges())
                 )

src/Model/Saved.py

@@ -20,6 +20,7 @@ import logging
 
 logger = logging.getLogger()
 
+
 class SavedStatus(object):
     def __init__(self):
         super(SavedStatus, self).__init__()

src/Model/SedimentLayer/SedimentLayer.py

@@ -5,6 +5,7 @@ from tools import trace, timer
 from Model.Tools.PamhyrDB import SQLSubModel
 from Model.Except import NotImplementedMethodeError
 
+
 class Layer(SQLSubModel):
     _sub_classes = []
     _id_cnt = 0
@@ -83,7 +84,7 @@ class Layer(SQLSubModel):
         self._critical_constraint = float(critical_constraint)
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         execute("""
           CREATE TABLE sedimentary_layer_layer(
             id INTEGER NOT NULL PRIMARY KEY,
@@ -102,21 +103,22 @@ class Layer(SQLSubModel):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         major, minor, release = version.strip().split(".")
         if major == minor == "0":
             if int(release) < 2:
-                cls._sql_create(execute)
+                cls._db_create(execute)
 
         return True
 
     @classmethod
-    def _sql_load(cls, execute, data = None):
+    def _db_load(cls, execute, data=None):
         new = []
         sl = data["sl"]
 
         table = execute(
-            "SELECT id, ind, name, type, height, d50, sigma, critical_constraint " +
+            "SELECT id, ind, name, type, height, " +
+            "d50, sigma, critical_constraint " +
             "FROM sedimentary_layer_layer " +
             f"WHERE sl = {sl}"
         )
@@ -139,16 +141,17 @@ class Layer(SQLSubModel):
 
         return new
 
-    def _sql_save(self, execute, data = None):
+    def _db_save(self, execute, data=None):
         ind = data["ind"]
         sl = data["sl"]
 
         sql = (
             "INSERT INTO " +
-            "sedimentary_layer_layer(id, ind, name, type, height, d50, sigma, critical_constraint, sl) "+
+            "sedimentary_layer_layer(id, ind, name, type, height, " +
+            "d50, sigma, critical_constraint, sl) " +
             "VALUES (" +
-            f"{self.id}, {ind}, '{self._sql_format(self._name)}', " +
+            f"{self.id}, {ind}, '{self._db_format(self._name)}', " +
-            f"'{self._sql_format(self._type)}', {self._height}, " +
+            f"'{self._db_format(self._type)}', {self._height}, " +
             f"{self._d50}, {self._sigma}, {self._critical_constraint}, " +
             f"{sl.id}" +
             ")"
@@ -196,7 +199,7 @@ class SedimentLayer(SQLSubModel):
 
     def height(self):
         return list(
-            map(lambda l: l.height, self._layers)
+            map(lambda layer: layer.height, self._layers)
         )
 
     @property
@@ -209,7 +212,7 @@ class SedimentLayer(SQLSubModel):
 
     def names(self):
         return list(
-            map(lambda l: l.name, self._layers)
+            map(lambda layer: layer.name, self._layers)
         )
 
     @property
@@ -221,7 +224,7 @@ class SedimentLayer(SQLSubModel):
         self._comment = comment
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         execute("""
           CREATE TABLE sedimentary_layer(
             id INTEGER NOT NULL PRIMARY KEY,
@@ -233,16 +236,16 @@ class SedimentLayer(SQLSubModel):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         major, minor, release = version.strip().split(".")
         if major == minor == "0":
             if int(release) < 2:
-                cls._sql_create(execute)
+                cls._db_create(execute)
 
         return True
 
     @classmethod
-    def _sql_load(cls, execute, data = None):
+    def _db_load(cls, execute, data=None):
         new = []
 
         table = execute(
@@ -259,29 +262,29 @@ class SedimentLayer(SQLSubModel):
             )
 
             data["sl"] = sl.id
-            sl._layers = Layer._sql_load(execute, data)
+            sl._layers = Layer._db_load(execute, data)
 
             new.append(sl)
 
         return new
 
-    def _sql_save(self, execute, data = None):
+    def _db_save(self, execute, data=None):
         if data is None:
             data = {}
 
         sql = (
             "INSERT INTO sedimentary_layer (id, name, comment) " +
-            f"VALUES ({self.id}, '{self._sql_format(self._name)}', " +
+            f"VALUES ({self.id}, '{self._db_format(self._name)}', " +
-            f"'{self._sql_format(self._comment)}')"
+            f"'{self._db_format(self._comment)}')"
         )
         execute(sql)
 
         data["sl"] = self
 
         ind = 0
-        for l in self._layers:
+        for layer in self._layers:
             data["ind"] = ind
-            l._sql_save(execute, data)
+            layer._db_save(execute, data)
             ind += 1
 
         return True
@@ -324,8 +327,8 @@ class SedimentLayer(SQLSubModel):
         if index >= 0:
             next = index - 1
 
-            l = self._layers
+            lst = self._layers
-            l[index], l[next] = l[next], l[index]
+            lst[index], lst[next] = lst[next], lst[index]
 
             self._status.modified()
 
@@ -333,7 +336,7 @@ class SedimentLayer(SQLSubModel):
         if index + 1 < len(self._layers):
             prev = index + 1
 
-            l = self._layers
+            lst = self._layers
-            l[index], l[prev] = l[prev], l[index]
+            lst[index], lst[prev] = lst[prev], lst[index]
 
             self._status.modified()

src/Model/SedimentLayer/SedimentLayerList.py

@@ -6,18 +6,19 @@ from Model.Except import NotImplementedMethodeError
 from Model.Tools.PamhyrList import PamhyrModelList
 from Model.SedimentLayer.SedimentLayer import SedimentLayer
 
+
 class SedimentLayerList(PamhyrModelList):
     _sub_classes = [SedimentLayer]
 
     @classmethod
-    def _sql_load(cls, execute, data = None):
+    def _db_load(cls, execute, data=None):
         new = cls(status=data["status"])
 
-        new._lst = SedimentLayer._sql_load(execute, data)
+        new._lst = SedimentLayer._db_load(execute, data)
 
         return new
 
-    def _sql_save(self, execute, data = None):
+    def _db_save(self, execute, data=None):
         ok = True
 
         # Delete previous data
@@ -25,7 +26,7 @@ class SedimentLayerList(PamhyrModelList):
         execute("DELETE FROM sedimentary_layer_layer")
 
         for sl in self._lst:
-            ok &= sl._sql_save(execute, data)
+            ok &= sl._db_save(execute, data)
 
         return ok
 

src/Model/Serializable.py

@@ -18,6 +18,7 @@
 
 import pickle
 
+
 class Serializable():
     def __init__(self):
         return

src/Model/SolverParameters/SolverParametersList.py

@@ -22,6 +22,7 @@ from Solver.Solvers import solver_type_list
 
 from Model.Tools.PamhyrList import PamhyrModelList
 
+
 class Parameter():
     def __init__(self,
                  name="", value="",
@@ -63,6 +64,7 @@ class Parameter():
 
         return new
 
+
 class SolverParametersList(PamhyrModelList):
     def __init__(self, solver_type=None, status=None):
         super(SolverParametersList, self).__init__()
@@ -76,9 +78,8 @@ class SolverParametersList(PamhyrModelList):
             )
         )
 
-
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         execute("""
           CREATE TABLE solver_parameter(
             id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
@@ -92,16 +93,23 @@ class SolverParametersList(PamhyrModelList):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         major, minor, release = version.strip().split(".")
 
         if major == minor == "0":
             if int(release) < 3:
-                execute(f"UPDATE solver_parameter SET name='mage_implicitation' WHERE name='mage_implication'")
+                execute(
-                execute(f"UPDATE solver_parameter SET name='mage_iteration_type' WHERE name='mage_iter_type'")
+                    "UPDATE solver_parameter SET name='mage_implicitation' " +
+                    "WHERE name='mage_implication'"
+                )
+                execute(
+                    "UPDATE solver_parameter SET name='mage_iteration_type' " +
+                    "WHERE name='mage_iter_type'"
+                )
 
             if int(release) < 4:
-                solvers = execute("SELECT DISTINCT solver FROM solver_parameter")
+                solvers = execute(
+                    "SELECT DISTINCT solver FROM solver_parameter")
 
                 for solver in solvers:
                     if solver != "mage8":
@@ -117,14 +125,14 @@ class SolverParametersList(PamhyrModelList):
                         f"WHERE solver = '{solver}'"
                     )
 
-                    insert = lambda name, value, ind: execute(
+                    def insert(name, value, ind): return execute(
                         "INSERT INTO " +
                         "solver_parameter(ind, name, value, solver) " +
                         "VALUES (" +
                         f"{ind}, " +
-                            f"'{cls._sql_format(name)}', " +
+                        f"'{cls._db_format(name)}', " +
-                            f"'{cls._sql_format(value)}', " +
+                        f"'{cls._db_format(value)}', " +
-                            f"'{cls._sql_format(solver)}'" +
+                        f"'{cls._db_format(solver)}'" +
                         ")"
                     )
 
@@ -134,6 +142,10 @@ class SolverParametersList(PamhyrModelList):
                         insert(v[0], v[1], ind)
                         ind += 1
 
+                    if int(release) < 7:
+                        insert("mage_init_internal", "N", ind)
+                        ind += 1
+
                     new = [
                         ("mage_sediment_masse_volumique", "2650.0"),
                         ("mage_sediment_angle_repos", "40.0"),
@@ -156,7 +168,7 @@ class SolverParametersList(PamhyrModelList):
         return cls._update_submodel(execute, version)
 
     @classmethod
-    def _sql_load(cls, execute, data = None):
+    def _db_load(cls, execute, data=None):
         status = data["status"]
         solvers = execute("SELECT DISTINCT solver FROM solver_parameter")
         new = {}
@@ -186,7 +198,7 @@ class SolverParametersList(PamhyrModelList):
 
         return new
 
-    def _sql_save(self, execute, data = None):
+    def _db_save(self, execute, data=None):
         t = self._solver._type
         execute(
             "DELETE FROM solver_parameter " +
@@ -200,9 +212,9 @@ class SolverParametersList(PamhyrModelList):
                 "solver_parameter(ind, name, value, solver) " +
                 "VALUES (" +
                 f"{ind}, " +
-                f"'{self._sql_format(param.name)}', " +
+                f"'{self._db_format(param.name)}', " +
-                f"'{self._sql_format(param.value)}', " +
+                f"'{self._db_format(param.value)}', " +
-                f"'{self._sql_format(t)}'" +
+                f"'{self._db_format(t)}'" +
                 ")"
             )
             execute(sql)
@@ -225,7 +237,7 @@ class SolverParametersList(PamhyrModelList):
                     self._lst
                 )
             )["value"]
-        except:
+        except Exception:
             return None
 
     def set(self, index, new):

src/Model/Stricklers/Stricklers.py

@@ -20,6 +20,7 @@ from tools import trace, timer
 
 from Model.Tools.PamhyrDB import SQLSubModel
 
+
 class Stricklers(SQLSubModel):
     _id_cnt = 0
     _sub_classes = []
@@ -46,9 +47,8 @@ class Stricklers(SQLSubModel):
         self._minor = minor
         self._medium = medium
 
-
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         execute("""
           CREATE TABLE stricklers(
             id INTEGER NOT NULL PRIMARY KEY,
@@ -62,11 +62,11 @@ class Stricklers(SQLSubModel):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return cls._update_submodel(execute, version)
 
     @classmethod
-    def _sql_load(cls, execute, data = None):
+    def _db_load(cls, execute, data=None):
         stricklers = []
         status = data["status"]
 
@@ -97,14 +97,14 @@ class Stricklers(SQLSubModel):
 
         return stricklers
 
-    def _sql_save(self, execute, data = None):
+    def _db_save(self, execute, data=None):
         sql = (
             "INSERT INTO " +
             "stricklers(id, name, comment, minor, medium) " +
             "VALUES (" +
             f"{self.id}, " +
-            f"'{self._sql_format(self.name)}', " +
+            f"'{self._db_format(self.name)}', " +
-            f"'{self._sql_format(self.comment)}', " +
+            f"'{self._db_format(self.comment)}', " +
             f"{float(self.minor)}, {float(self.medium)}" +
             ")"
         )

src/Model/Stricklers/StricklersList.py

@@ -22,31 +22,32 @@ from Model.Saved import SavedStatus
 from Model.Tools.PamhyrList import PamhyrModelList
 from Model.Stricklers.Stricklers import Stricklers
 
+
 class StricklersList(PamhyrModelList):
     _sub_classes = [
         Stricklers,
     ]
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return cls._update_submodel(execute, version)
 
     @classmethod
-    def _sql_load(cls, execute, data = None):
+    def _db_load(cls, execute, data=None):
         new = cls(status=data["status"])
 
-        new._lst = Stricklers._sql_load(
+        new._lst = Stricklers._db_load(
             execute,
             data=data
         )
 
         return new
 
-    def _sql_save(self, execute, data = None):
+    def _db_save(self, execute, data=None):
         execute("DELETE FROM stricklers")
 
         objs = self._lst
@@ -63,7 +64,7 @@ class StricklersList(PamhyrModelList):
 
     @timer
     def sort(self, reverse: bool = False, key=None):
-        f = lambda st: st.name
+        def f(st): return st.name
         if key is not None:
             f = key
 
@@ -72,4 +73,6 @@ class StricklersList(PamhyrModelList):
             key=f,
             reverse=reverse,
         )
+
+        if self._status is not None:
             self._status.modified()

src/Model/Study.py

@@ -33,6 +33,7 @@ from Checker.Study import *
 
 logger = logging.getLogger()
 
+
 class Study(SQLModel):
     _sub_classes = [
         River,
@@ -40,7 +41,7 @@ class Study(SQLModel):
 
     def __init__(self, filename=None, init_new=True):
         # Metadata
-        self._version = "0.0.4"
+        self._version = "0.0.7"
         self.creation_date = datetime.now()
         self.last_modification_date = datetime.now()
         self.last_save_date = datetime.now()
@@ -85,7 +86,7 @@ class Study(SQLModel):
     def is_saved(self):
         return self.status.is_saved()
 
-    def save(self):
+    def save(self, progress=None):
         # Save a copy of database
         fdir, fname = os.path.split(self.filename)
 
@@ -109,7 +110,7 @@ class Study(SQLModel):
 
         # Save
         self.last_save_date = datetime.now()
-        self._save()
+        self._save(progress=progress)
         self.status.save()
 
     @property
@@ -176,16 +177,26 @@ class Study(SQLModel):
     # SQL #
     #######
 
+    def _db_insert_into_info(self, key, value, commit=False):
+        self.execute(
+            "INSERT INTO info VALUES " +
+            f"('{key}', '{self._db_format(value)}')",
+            commit=commit
+        )
+
     def _create(self):
         # Info (metadata)
-        self.execute("CREATE TABLE info(key TEXT NOT NULL UNIQUE, value TEXT NOT NULL)")
         self.execute(
-            f"INSERT INTO info VALUES ('version', '{self._sql_format(self._version)}')",
+            "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)}')",
             commit=True
         )
         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}')")
+        self.execute(
+            f"INSERT INTO info VALUES ('time_system', '{self._time_system}')")
         self.execute(
             f"INSERT INTO info VALUES ('date', " +
             "'{self._date.timestamp()}')"
@@ -213,7 +224,8 @@ class Study(SQLModel):
         logger.info("Update database")
 
         if self._update_submodel(version[0]):
-            self.execute(f"UPDATE info SET value='{self._version}' WHERE key='version'")
+            self.execute(
+                f"UPDATE info SET value='{self._version}' WHERE key='version'")
             return True
 
         logger.info("TODO: update failed")
@@ -225,21 +237,25 @@ class Study(SQLModel):
 
         # TODO: Load metadata
         new.name = new.execute("SELECT value FROM info WHERE key='name'")[0]
-        new.description = new.execute("SELECT value FROM info WHERE key='description'")[0]
+        new.description = new.execute(
-        new._time_system = new.execute("SELECT value FROM info WHERE key='time_system'")[0]
+            "SELECT value FROM info WHERE key='description'")[0]
+        new._time_system = new.execute(
+            "SELECT value FROM info WHERE key='time_system'")[0]
         new._date = datetime.fromtimestamp(
             float(new.execute("SELECT value FROM info WHERE key='date'")[0])
         )
 
         new.creation_date = datetime.fromtimestamp(
-            float(new.execute("SELECT value FROM info WHERE key='creation_date'")[0])
+            float(new.execute(
+                "SELECT value FROM info WHERE key='creation_date'")[0])
         )
         new.last_save_date = datetime.fromtimestamp(
-            float(new.execute("SELECT value FROM info WHERE key='last_save_date'")[0])
+            float(new.execute(
+                "SELECT value FROM info WHERE key='last_save_date'")[0])
         )
 
         # Load river data
-        new._river = River._sql_load(
+        new._river = River._db_load(
             lambda sql: new.execute(
                 sql,
                 fetch_one=False,
@@ -250,13 +266,58 @@ class Study(SQLModel):
 
         return new
 
-    def _save(self):
+    def _save(self, progress=None):
-        self.execute(f"UPDATE info SET value='{self._sql_format(self.name)}' WHERE key='name'")
+        progress = progress if progress is not None else lambda: None
-        self.execute(f"UPDATE info SET value='{self._sql_format(self.description)}' WHERE key='description'")
-        self.execute(f"UPDATE info SET value='{self._time_system}' WHERE key='time_system'")
-        self.execute(f"UPDATE info SET value='{timestamp(self._date)}' WHERE key='date'")
-        self.execute(f"UPDATE info SET value='{timestamp(self.creation_date)}' WHERE key='creation_date'")
-        self.execute(f"UPDATE info SET value='{timestamp(self.last_save_date)}' WHERE key='last_save_date'")
 
-        self._save_submodel([self._river])
+        self.execute(
+            f"UPDATE info SET " +
+            f"value='{self._db_format(self.name)}' WHERE key='name'"
+        )
+        progress()
+        self.execute(
+            f"UPDATE info SET " +
+            f"value='{self._db_format(self.description)}' " +
+            "WHERE key='description'"
+        )
+        progress()
+        self.execute(
+            f"UPDATE info SET " +
+            f"value='{self._time_system}' WHERE key='time_system'"
+        )
+        progress()
+        self.execute(
+            f"UPDATE info SET " +
+            f"value='{timestamp(self._date)}' WHERE key='date'"
+        )
+        progress()
+        self.execute(
+            f"UPDATE info SET " +
+            f"value='{timestamp(self.creation_date)}' " +
+            "WHERE key='creation_date'"
+        )
+        progress()
+        self.execute(
+            f"UPDATE info SET " +
+            f"value='{timestamp(self.last_save_date)}' " +
+            "WHERE key='last_save_date'"
+        )
+        progress()
+
+        self._save_submodel([self._river], data=progress)
         self.commit()
+
+    def sql_save_request_count(self):
+        return self._count()
+
+    def _count(self):
+        cnt = self._save_count([self._river])
+        logger.debug(cnt)
+        return cnt + 6
+
+    def close(self):
+        """Close db connection
+
+        Returns:
+            Nothing.
+        """
+        self._close()

src/Model/Tools/PamhyrDB.py

@@ -21,6 +21,7 @@ import sqlite3
 import logging
 
 from pathlib import Path
+from functools import reduce
 
 from tools import SQL
 from Model.Except import NotImplementedMethodeError
@@ -28,6 +29,8 @@ from Model.Except import NotImplementedMethodeError
 logger = logging.getLogger()
 
 # Top level model class
+
+
 class SQLModel(SQL):
     _sub_classes = []
 
@@ -48,19 +51,18 @@ class SQLModel(SQL):
             self._update()      # Update db scheme if necessary
             # self._load()        # Load data
 
-
     def __init__(self, filename=None):
         self._db = None
 
     def _create_submodel(self):
-        fn = lambda sql: self.execute(
+        def fn(sql): return self.execute(
             sql,
             fetch_one=False,
             commit=False
         )
 
         for cls in self._sub_classes:
-            requests = cls._sql_create(fn)
+            requests = cls._db_create(fn)
 
         self.commit()
         return True
@@ -69,7 +71,7 @@ class SQLModel(SQL):
         raise NotImplementedMethodeError(self, self._create)
 
     def _update_submodel(self, version):
-        fn = lambda sql: self.execute(
+        def fn(sql): return self.execute(
             sql,
             fetch_one=False,
             commit=False
@@ -77,7 +79,7 @@ class SQLModel(SQL):
 
         ok = True
         for cls in self._sub_classes:
-            ok &= cls._sql_update(fn, version)
+            ok &= cls._db_update(fn, version)
 
         self.commit()
         return ok
@@ -86,45 +88,86 @@ class SQLModel(SQL):
         raise NotImplementedMethodeError(self, self._update)
 
     def _save_submodel(self, objs, data=None):
-        fn = lambda sql: self.execute(
+        progress = data if data is not None else lambda: None
+
+        def fn(sql):
+            res = self.execute(
                 sql,
                 fetch_one=False,
                 commit=False
             )
+            progress()
+            return res
 
         ok = True
         for obj in objs:
-            ok &= obj._sql_save(fn)
+            ok &= obj._db_save(fn)
 
         self.commit()
         return ok
 
-    def _save(self):
+    def _save(self, progress=None):
         raise NotImplementedMethodeError(self, self._save)
 
+    def _count(self):
+        raise NotImplementedMethodeError(self, self._count)
+
+    def _save_count(self, objs, data=None):
+        counter = {
+            "insert": 0,
+            "update": 0,
+            "delete": 0,
+            "other": 0,
+        }
+
+        def fn(sql):
+            if "insert" in sql.lower():
+                counter["insert"] = counter["insert"] + 1
+            elif "update" in sql.lower():
+                counter["update"] = counter["update"] + 1
+            elif "delete" in sql.lower():
+                counter["delete"] = counter["delete"] + 1
+            else:
+                counter["other"] = counter["other"] + 1
+            return []
+
+        ok = True
+        for obj in objs:
+            ok &= obj._db_save(fn)
+
+        logger.debug(counter)
+
+        return reduce(
+            lambda acc, k: acc + counter[k],
+            counter,
+            0
+        )
+
     @classmethod
     def _load(cls, filename=None):
         raise NotImplementedMethodeError(cls, cls._load)
 
 # Sub model class
+
+
 class SQLSubModel(object):
     _sub_classes = []
 
-    def _sql_format(self, value):
+    def _db_format(self, value):
         # Replace ''' by ''' to preserve SQL injection
-        if type(value) == str:
+        if type(value) is str:
             value = value.replace("'", "'")
-        elif type(value) == bool:
+        elif type(value) is bool:
             value = 'TRUE' if value else 'FALSE'
         return value
 
     @classmethod
     def _create_submodel(cls, execute):
         for sc in cls._sub_classes:
-            sc._sql_create(execute)
+            sc._db_create(execute)
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         """Create data base scheme
 
         Args:
@@ -133,15 +176,15 @@ class SQLSubModel(object):
         Returns:
             Return true, otherelse false if an issue appear
         """
-        raise NotImplementedMethodeError(cls, cls._sql_create)
+        raise NotImplementedMethodeError(cls, cls._db_create)
 
     @classmethod
     def _update_submodel(cls, execute, version):
         for sc in cls._sub_classes:
-            sc._sql_update(execute, version)
+            sc._db_update(execute, version)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         """Update data base scheme
 
         Args:
@@ -151,10 +194,10 @@ class SQLSubModel(object):
         Returns:
             Return true, otherelse false if an issue appear
         """
-        raise NotImplementedMethodeError(cls, cls._sql_update)
+        raise NotImplementedMethodeError(cls, cls._db_update)
 
     @classmethod
-    def _sql_load(cls, execute, data = None):
+    def _db_load(cls, execute, data=None):
         """Load instance of this class from SQL data base
 
         Args:
@@ -164,13 +207,13 @@ class SQLSubModel(object):
         Returns:
             Return new instance of class
         """
-        raise NotImplementedMethodeError(cls, cls._sql_load)
+        raise NotImplementedMethodeError(cls, cls._db_load)
 
     def _save_submodel(self, execute, objs, data=None):
         for o in objs:
-            o._sql_save(execute, data = data)
+            o._db_save(execute, data=data)
 
-    def _sql_save(self, execute, data = None):
+    def _db_save(self, execute, data=None):
         """Save class data to data base
 
         Args:
@@ -181,4 +224,4 @@ class SQLSubModel(object):
             Return true, otherelse false if an issue appear during
             save
         """
-        raise NotImplementedMethodeError(self, self._sql_save)
+        raise NotImplementedMethodeError(self, self._db_save)

src/Model/Tools/PamhyrDict.py

@@ -16,6 +16,7 @@
 
 # -*- coding: utf-8 -*-
 
+import types
 import logging
 
 from copy import copy
@@ -38,19 +39,19 @@ class PamhyrModelDict(SQLSubModel):
         self._dict = {}
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return cls._update_submodel(execute, version)
 
     @classmethod
-    def _sql_load(cls, execute, data = None):
+    def _db_load(cls, execute, data=None):
-        raise NotImplementedMethodeError(cls, cls._sql_load)
+        raise NotImplementedMethodeError(cls, cls._db_load)
 
-    def _sql_save(self, execute, data = None):
+    def _db_save(self, execute, data=None):
-        raise NotImplementedMethodeError(self, self._sql_save)
+        raise NotImplementedMethodeError(self, self._db_save)
 
     def __len__(self):
         return len(self._dict)
@@ -64,7 +65,12 @@ class PamhyrModelDict(SQLSubModel):
 
     def get(self, key):
         if key in self._dict:
-            return self._dict[key]
+            v = self._dict[key]
+
+            if type(v) is types.GeneratorType:
+                return list(v)
+
+            return v
 
         new = self.new(key)
         self.set(key, new)

src/Model/Tools/PamhyrList.py

@@ -26,6 +26,7 @@ from Model.Except import NotImplementedMethodeError
 
 logger = logging.getLogger()
 
+
 class PamhyrModelList(SQLSubModel):
     _sub_classes = [
     ]
@@ -41,36 +42,37 @@ class PamhyrModelList(SQLSubModel):
     #######
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return cls._update_submodel(execute, version)
 
     @classmethod
-    def _sql_load(cls, execute, data = None):
+    def _db_load(cls, execute, data=None):
-        raise NotImplementedMethodeError(cls, cls._sql_load)
+        raise NotImplementedMethodeError(cls, cls._db_load)
 
-    def _sql_save(self, execute, data = None):
+    def _db_save(self, execute, data=None):
-        raise NotImplementedMethodeError(self, self._sql_save)
+        raise NotImplementedMethodeError(self, self._db_save)
 
     ################
     # MODEL METHOD #
     ################
 
-    def __len__(self):
-        return len(self._lst)
-
     @property
     def lst(self):
-        return self._lst.copy()
+        return self._lst
+
+    def __len__(self):
+        return len(self.lst)
 
     def get(self, row):
         return self._lst[row]
 
     def set(self, row, new):
         self._lst[row] = new
+        if self._status is not None:
             self._status.modified()
 
     def new(self, index):
@@ -86,11 +88,15 @@ class PamhyrModelList(SQLSubModel):
 
     def insert(self, index, new):
         self._lst.insert(index, new)
+
+        if self._status is not None:
             self._status.modified()
 
     def delete(self, lst):
         for el in lst:
             self._lst.remove(el)
+
+        if self._status is not None:
             self._status.modified()
 
     def delete_i(self, indexes):
@@ -107,22 +113,28 @@ class PamhyrModelList(SQLSubModel):
 
     def sort(self, reverse=False, key=None):
         self._lst.sort(reverse=reverse, key=key)
+
+        if self._status is not None:
             self._status.modified()
 
     def move_up(self, index):
         if index < len(self._lst):
             next = index - 1
 
-            l = self._lst
+            lst = self._lst
-            l[index], l[next] = l[next], l[index]
+            lst[index], lst[next] = lst[next], lst[index]
+
+            if self._status is not None:
                 self._status.modified()
 
     def move_down(self, index):
         if index >= 0:
             prev = index + 1
 
-            l = self._lst
+            lst = self._lst
-            l[index], l[prev] = l[prev], l[index]
+            lst[index], lst[prev] = lst[prev], lst[index]
+
+            if self._status is not None:
                 self._status.modified()
 
 
@@ -144,19 +156,19 @@ class PamhyrModelListWithTab(SQLSubModel):
     #######
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return cls._update_submodel(execute, version)
 
     @classmethod
-    def _sql_load(cls, execute, data = None):
+    def _db_load(cls, execute, data=None):
-        raise NotImplementedMethodeError(cls, cls._sql_load)
+        raise NotImplementedMethodeError(cls, cls._db_load)
 
-    def _sql_save(self, execute, data = None):
+    def _db_save(self, execute, data=None):
-        raise NotImplementedMethodeError(self, self._sql_save)
+        raise NotImplementedMethodeError(self, self._db_save)
 
     ################
     # MODEL METHOD #
@@ -216,14 +228,14 @@ class PamhyrModelListWithTab(SQLSubModel):
         if index < len(self._tabs[lst]):
             next = index - 1
 
-            l = self._tabs[lst]
+            lst = self._tabs[lst]
-            l[index], l[next] = l[next], l[index]
+            lst[index], lst[next] = lst[next], lst[index]
             self._status.modified()
 
     def move_down(self, lst, index):
         if index >= 0:
             prev = index + 1
 
-            l = self._tabs[lst]
+            lst = self._tabs[lst]
-            l[index], l[prev] = l[prev], l[index]
+            lst[index], lst[prev] = lst[prev], lst[index]
             self._status.modified()

src/Model/__init__.py

@@ -0,0 +1,17 @@
+# __init__.py -- Pamhyr
+# Copyright (C) 2023  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 -*-

src/Model/test_Model.py

@@ -0,0 +1,110 @@
+# test_Model.py -- Pamhyr
+# Copyright (C) 2023  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 unittest
+import tempfile
+
+from Model.Saved import SavedStatus
+from Model.Study import Study
+from Model.River import River
+
+
+class StudyTestCase(unittest.TestCase):
+    def test_create_study(self):
+        study = Study.new("foo", "bar")
+        self.assertEqual(study.name, "foo")
+        self.assertEqual(study.description, "bar")
+
+    def test_open_study(self):
+        study = Study.open("../tests_cases/Enlargement/Enlargement.pamhyr")
+        self.assertNotEqual(study, None)
+        self.assertEqual(study.name, "Enlargement")
+
+    def test_save_open_study(self):
+        study = Study.new("foo", "bar")
+        dir = tempfile.mkdtemp()
+        f = os.path.join(dir, "foo.pamhyr")
+
+        # Save study
+        study.filename = f
+        study.save()
+        study.close()
+
+        # Reopen study
+        study = Study.open(f)
+
+        # Check
+        self.assertNotEqual(study, None)
+        self.assertEqual(study.name, "foo")
+        self.assertEqual(study.description, "bar")
+
+    def test_create_study_river(self):
+        study = Study.new("foo", "bar")
+        self.assertNotEqual(study.river, None)
+
+
+class RiverTestCase(unittest.TestCase):
+    def test_create_river(self):
+        status = SavedStatus()
+        river = River(status=status)
+
+        self.assertNotEqual(river, None)
+
+    def test_create_river_nodes(self):
+        status = SavedStatus()
+        river = River(status=status)
+
+        self.assertNotEqual(river, None)
+
+        # Add nodes
+        n0 = river.add_node()
+        n1 = river.add_node(x=1.0, y=0.0)
+        n2 = river.add_node(x=0.0, y=1.0)
+
+        # Checks
+        self.assertEqual(river.nodes_counts(), 3)
+
+        nodes = river.nodes()
+        self.assertEqual(nodes[0], n0)
+        self.assertEqual(nodes[1], n1)
+        self.assertEqual(nodes[2], n2)
+
+    def test_create_river_edges(self):
+        status = SavedStatus()
+        river = River(status=status)
+
+        self.assertNotEqual(river, None)
+
+        # Add nodes
+        n0 = river.add_node()
+        n1 = river.add_node(x=1.0, y=0.0)
+        n2 = river.add_node(x=0.0, y=1.0)
+
+        self.assertEqual(river.nodes_counts(), 3)
+
+        # Add edges
+        e0 = river.add_edge(n0, n1)
+        e1 = river.add_edge(n1, n2)
+
+        # Checks
+        self.assertEqual(river.edges_counts(), 2)
+
+        edges = river.edges()
+        self.assertEqual(edges[0], e0)
+        self.assertEqual(edges[1], e1)

src/Scripts/AScript.py

@@ -18,6 +18,7 @@
 
 from Model.Except import NotImplementedMethodeError
 
+
 class AScript(object):
     name = ""
     description = ""

src/Scripts/Hello.py

@@ -1,4 +1,4 @@
-# help.py -- Pamhyr
+# Hello.py -- Pamhyr
 # Copyright (C) 2023  INRAE
 #
 # This program is free software: you can redistribute it and/or modify

src/Scripts/ListSolver.py

@@ -0,0 +1,38 @@
+# ListSolver.py -- Pamhyr
+# Copyright (C) 2023  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import os
+import logging
+
+from Scripts.AScript import AScript
+
+logger = logging.getLogger()
+
+
+class ScriptListSolver(AScript):
+    name = "ListSolver"
+    description = "List configured solver(s) for Pamhyr2"
+
+    def usage(self):
+        logger.info(f"Usage : {self._args[0]} {self._args[1]}")
+
+    def run(self):
+        for solver in self._conf.solvers:
+            print(f"{solver.name:<16} ({solver.type}): {solver.description}")
+
+        return 0

src/Scripts/MageMesh.py

@@ -0,0 +1,289 @@
+# MageMesh.py -- Pamhyr
+# Copyright (C) 2023  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import os
+import logging
+
+from ctypes import (
+    cdll,
+    byref, Structure,
+    c_char_p, c_wchar_p,
+    create_string_buffer,
+    POINTER, c_void_p,
+    c_int, c_double, c_bool
+)
+
+from Scripts.AScript import AScript
+
+logger = logging.getLogger()
+
+bief_lib = None
+c_init_bief_from_geo_file = None
+c_get_nb_sections = None
+c_get_nb_points_section = None
+c_set_bief_name = None
+c_st_to_m_compl = None
+c_interpolate_profils_pas_transversal = None
+c_update_pk = None
+c_output_bief = None
+
+##########################
+# Binding initialisation #
+##########################
+
+
+def init_clib(lib_path):
+    global bief_lib
+    bief_lib = cdll.LoadLibrary(lib_path)
+
+    init_c_init_bief_from_geo_file(bief_lib)
+    init_c_get_nb_sections(bief_lib)
+    init_c_get_nb_points_section(bief_lib)
+    init_c_set_bief_name(bief_lib)
+    init_c_st_to_m_compl(bief_lib)
+    init_c_interpolate_profils_pas_transversal(bief_lib)
+    init_c_update_pk(bief_lib)
+    init_c_output_bief(bief_lib)
+
+
+def init_c_init_bief_from_geo_file(bief_lib):
+    global c_init_bief_from_geo_file
+
+    c_init_bief_from_geo_file = getattr(
+        bief_lib, 'c_init_bief_from_geo_file'
+    )
+    c_init_bief_from_geo_file.argtypes = [
+        c_char_p, POINTER(c_int), POINTER(c_int)
+    ]
+    c_init_bief_from_geo_file.restype = None
+
+
+def init_c_get_nb_sections(bief_lib):
+    global c_get_nb_sections
+
+    c_get_nb_sections = getattr(bief_lib, 'c_get_nb_sections')
+    c_get_nb_sections.argtypes = [POINTER(c_int)]
+    c_get_nb_sections.restype = None
+
+
+def init_c_get_nb_points_section(bief_lib):
+    global c_get_nb_points_section
+
+    c_get_nb_points_section = getattr(bief_lib, 'c_get_nb_points_section')
+    c_get_nb_points_section.argtypes = [POINTER(c_int), POINTER(c_int)]
+    c_get_nb_points_section.restype = None
+
+
+def init_c_set_bief_name(bief_lib):
+    global c_set_bief_name
+
+    c_set_bief_name = getattr(bief_lib, 'c_set_bief_name')
+    c_set_bief_name.argtypes = [c_char_p]
+    c_set_bief_name.restype = None
+
+
+def init_c_st_to_m_compl(bief_lib):
+    global c_st_to_m_compl
+
+    c_st_to_m_compl = getattr(bief_lib, 'c_st_to_m_compl')
+    c_st_to_m_compl.argtypes = [POINTER(c_int), c_char_p, c_char_p]
+    c_st_to_m_compl.restype = None
+
+
+def init_c_interpolate_profils_pas_transversal(bief_lib):
+    global c_interpolate_profils_pas_transversal
+
+    c_interpolate_profils_pas_transversal = getattr(
+        bief_lib, 'c_interpolate_profils_pas_transversal'
+    )
+    c_interpolate_profils_pas_transversal.argtypes = [
+        POINTER(c_int), POINTER(c_int),
+        c_char_p, c_char_p,
+        POINTER(c_double), POINTER(c_bool),
+        POINTER(c_int), POINTER(c_bool)
+    ]
+    c_interpolate_profils_pas_transversal.restype = None
+
+
+def init_c_update_pk(bief_lib):
+    global c_update_pk
+
+    c_update_pk = getattr(bief_lib, 'c_update_pk')
+    c_update_pk.argtypes = [c_char_p]
+    c_update_pk.restype = None
+
+
+def init_c_output_bief(bief_lib):
+    global c_output_bief
+
+    c_output_bief = getattr(bief_lib, 'c_output_bief')
+    c_output_bief.argtypes = [c_char_p]
+    c_output_bief.restype = None
+
+
+def init_bief_from_geo_file(name, with_charriage, with_water):
+    logger.info("! call init_bief_from_geo_file:")
+    cname = create_string_buffer(name.encode())
+    c_init_bief_from_geo_file(
+        cname,
+        byref(c_int(with_charriage)),
+        byref(c_int(with_water))
+    )
+
+#####################
+# Binding functions #
+#####################
+
+
+def get_nb_sections():
+    nb_sections = c_int(0)
+    c_get_nb_sections(byref(nb_sections))
+    return nb_sections.value
+
+
+def get_nb_points_section(section):
+    nb_points = c_int(0)
+    c_get_nb_points_section(byref(c_int(section)), byref(nb_points))
+    return nb_points.value
+
+
+def set_bief_name(name):
+    logger.info(f"! call set_bief_name: {repr(name)}")
+    cname = create_string_buffer(name.encode())
+    c_set_bief_name(cname)
+
+
+def st_to_m_compl(npoints, tag1='   ', tag2='   '):
+    logger.info(f"! call st_to_m_compl: {npoints}")
+    cnpoints = c_int(npoints)
+    ctag1 = create_string_buffer(tag1.encode())
+    ctag2 = create_string_buffer(tag2.encode())
+
+    c_st_to_m_compl(byref(cnpoints), ctag1, ctag2)
+
+
+def interpolate_profils_pas_transversal(limite1, limite2,
+                                        directrice1, directrice2,
+                                        pas, lplan=False,
+                                        lm=3, lineaire=False):
+    logger.info("! call interpolate_profils_pas_transversal:")
+    climite1 = c_int(limite1)
+    climite2 = c_int(limite2)
+    cpas = c_double(pas)
+    clplan = c_bool(lplan)
+    clm = c_int(lm)
+    clineaire = c_bool(lineaire)
+    cdirectrice1 = create_string_buffer(directrice1.encode())
+    cdirectrice2 = create_string_buffer(directrice2.encode())
+
+    c_interpolate_profils_pas_transversal(
+        byref(climite1), byref(climite2),
+        cdirectrice1, cdirectrice2,
+        byref(cpas), byref(clplan),
+        byref(clm), byref(clineaire)
+    )
+
+
+def update_pk(directrice):
+    logger.info("! call update_pk:")
+    cdirectrice = create_string_buffer(directrice.encode())
+    c_update_pk(cdirectrice)
+
+
+def output_bief(name):
+    logger.info("! call output_bief:")
+    cname = create_string_buffer(name.encode())
+    c_output_bief(cname)
+
+
+##########
+# Script #
+##########
+
+
+class MageMesh(AScript):
+    name = "MageMesh"
+    description = "Mesh ST file to M"
+
+    def usage(self):
+        logger.info(
+            f"Usage : {self._args[0]} {self._args[1]} " +
+            "<SO_FILE> <ST_FILE> <STEP>"
+        )
+
+    def run(self):
+        if len(self._args) < 5:
+            return 1
+
+        try:
+            so = self._args[2]
+            st = self._args[3]
+            step = float(self._args[4])
+        except Exception as e:
+            logger.error(f"Argument format error: {e}")
+            return 2
+
+        try:
+            init_clib(so)
+        except Exception as e:
+            logger.error(f"Bindings failed: {e}")
+            return 3
+
+        self.meshing(st, step)
+
+        return 0
+
+    def meshing(self, st_file: str, step: float):
+        workdir = self.get_workdir(st_file)
+        file_name = st_file.rsplit(".", 1)[0]
+        reach_name = os.path.basename(file_name)
+
+        # Open
+        init_bief_from_geo_file(st_file, 0, 0)
+        set_bief_name(reach_name)
+
+        ns = get_nb_sections()
+        npts_max = max(
+            map(
+                lambda i: get_nb_points_section(i),
+                range(1, ns)
+            )
+        )
+
+        # Transform
+        st_to_m_compl(npts_max, 'rg', 'rd')
+        interpolate_profils_pas_transversal(
+            1, ns,
+            'un', 'np',
+            step
+        )
+        update_pk("un")
+
+        # Save
+        logger.info(f"Saved meshing geometry to {file_name}.M")
+        output_bief(f"{file_name}.M")
+
+    def get_workdir(self, file):
+        workdir = os.path.abspath(
+            os.path.dirname(file)
+        )
+
+        os.makedirs(workdir, exist_ok=True)
+        logger.info(f"Set working dir to {workdir}")
+
+        return workdir

src/Scripts/P3DST.py

@@ -0,0 +1,116 @@
+# P3DST.py -- Pamhyr
+# Copyright (C) 2023  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 sys
+import logging
+
+from matplotlib import pyplot as plt
+from numpy import mean
+
+from Scripts.AScript import AScript
+
+from Model.Saved import SavedStatus
+from Model.Geometry.Reach import Reach
+
+logger = logging.getLogger()
+
+
+class Script3DST(AScript):
+    name = "3DST"
+    description = "Display a 3D plot of a river reach from ST file"
+
+    def usage(self):
+        logger.info(f"Usage : {self._args[0]} 3DST <INPUT_ST_FILE>")
+
+    def set_axes_equal(self, ax):
+        """Make axes of 3D plot have equal scale
+
+        Make axes of 3D plot have equal scale so that spheres appear
+        as spheres, cubes as cubes, etc.. This is one possible
+        solution to Matplotlib's ax.set_aspect('equal') and
+        ax.axis('equal') not working for 3D.
+
+        Args:
+            ax: a matplotlib axis, e.g., as output from plt.gca()
+
+        Returns:
+            The input axis
+        """
+        x_limits = ax.get_xlim3d()
+        y_limits = ax.get_ylim3d()
+        z_limits = ax.get_zlim3d()
+
+        x_range = abs(x_limits[1] - x_limits[0])
+        x_middle = mean(x_limits)
+        y_range = abs(y_limits[1] - y_limits[0])
+        y_middle = mean(y_limits)
+        z_range = abs(z_limits[1] - z_limits[0])
+        z_middle = mean(z_limits)
+
+        # The plot bounding box is a sphere in the sense of the infinity
+        # norm, hence I call half the max range the plot radius.
+        plot_radius = 0.5*max([x_range, y_range, z_range])
+
+        ax.set_xlim3d([x_middle - plot_radius, x_middle + plot_radius])
+        ax.set_ylim3d([y_middle - plot_radius, y_middle + plot_radius])
+        ax.set_zlim3d([z_middle - plot_radius, z_middle + plot_radius])
+
+        return ax
+
+    def run(self):
+        try:
+            st_file = self._args[2]
+            logger.info(f"Use ST file: {st_file}")
+        except Exception as e:
+            logger.error(f"Arguments parcing: {str(e)}")
+            return 1
+
+        try:
+            status = SavedStatus()
+
+            my_reach = Reach(status=status)
+            my_reach.import_geometry(st_file)
+            my_reach.compute_guidelines()
+
+            ax = plt.figure().add_subplot(projection="3d")
+            logger.info(my_reach.get_x())
+            for x, y, z in zip(
+                    my_reach.get_x(),
+                    my_reach.get_y(),
+                    my_reach.get_z()
+            ):
+                ax.plot(x, y, z, color='r', lw=1.)
+
+            for x, y, z in zip(
+                    my_reach.get_guidelines_x(),
+                    my_reach.get_guidelines_y(),
+                    my_reach.get_guidelines_z()
+            ):
+                ax.plot(x, y, z, color='b', lw=1.)
+
+            ax.set_xlabel('X')
+            ax.set_ylabel('Y')
+            ax.set_zlabel('Z')
+            plt.tight_layout()
+            self.set_axes_equal(ax)
+            plt.show()
+
+            return 0
+        except Exception as e:
+            logger.error(str(e))
+            return 1

src/Scripts/Run.py

@@ -0,0 +1,113 @@
+# Run.py -- Pamhyr
+# Copyright (C) 2023  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import os
+import logging
+
+from queue import Queue
+
+from PyQt5.QtCore import QProcess
+
+from Scripts.AScript import AScript
+from Model.Study import Study
+
+logger = logging.getLogger()
+
+
+class ScriptRun(AScript):
+    name = "Run"
+    description = "Run solver on Pamhyr2 a study"
+
+    def usage(self):
+        logger.info(
+            f"Usage : {self._args[0]} {self._args[1]} " +
+            "<SOLVER> <STUDY>"
+        )
+
+    def run(self):
+        if len(self._args) < 4:
+            return 1
+
+        command = self._args[1]
+        solver_name = self._args[2]
+        study_file = os.path.abspath(
+            self._args[3]
+        )
+
+        try:
+            solver = next(
+                filter(
+                    lambda solver: solver.name == solver_name,
+                    self._conf.solvers
+                )
+            )
+        except Exception as e:
+            logger.error(f"No solver found: {e}")
+            return 2
+
+        study = Study.open(study_file)
+
+        self._solver = solver
+        self._study = study
+
+        logger.info(
+            f"Run {solver.name} ({solver.type}) " +
+            "on study '{study.name}' ({study_file})"
+        )
+
+        # Workdir
+        workdir = os.path.join(
+            os.path.dirname(study.filename),
+            "_PAMHYR_",
+            study.name.replace(" ", "_"),
+            solver.name.replace(" ", "_")
+        )
+        os.makedirs(workdir, exist_ok=True)
+        logger.info(f"Set working dir to {workdir}")
+
+        # Preparate process
+        p = QProcess(None)
+        p.setWorkingDirectory(workdir)
+
+        self._q = Queue()
+
+        # Export and Run
+        logger.info(f"~Export~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
+        solver.export(study, workdir, qlog=self._q)
+
+        while self._q.qsize() != 0:
+            s = self._q.get()
+            logger.info(s)
+
+        if command == "run":
+            logger.info(f"~Run~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
+            solver.run(
+                study,
+                process=p,
+                output_queue=self._q
+            )
+            p.waitForFinished()
+
+        logger.info(f"~End~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
+
+        return 0
+
+
+class ScriptExport(ScriptRun):
+    name = "Export"
+    description = "Export Pamhyr2 study for solver"

src/Scripts/mage_to_mascaret.py

@@ -0,0 +1,341 @@
+#!/bin/env python3
+
+import sys
+import importlib.util as imp
+import os
+import datetime as dt
+import lxml.etree as ET
+
+def mage_to_mascaret(filename):
+    # rep file
+    with open(filename, encoding = "ISO-8859-1", mode ="r") as rep:
+        lines = rep.readlines()
+        for line in lines:
+            l = line.split()
+            if (l[0] == 'PAR'):
+                parfile = l[1]
+            elif (l[0] == 'NET'):
+                netfile = l[1]
+            elif (l[0] == 'HYD'):
+                hydfile = l[1]
+            elif (l[0] == 'RUG'):
+                rugfile = l[1]
+            elif (l[0] == 'LIM'):
+                limfile = l[1]
+            elif (l[0] == 'INI'):
+                inifile = l[1]
+
+    # net file
+    with open(netfile, encoding = "ISO-8859-1", mode ="r") as net:
+        lines = net.readlines()
+        for line in lines:
+            if (line[0] != '*' and line[0] != '$'):
+                l = line.split()
+                biefname = l[0]
+                stfile = l[3]
+                break # on n'utilise que le premier bief pour le moment
+
+
+    # geometry file
+
+    print("geometrie fie : "+stfile)
+    wb.init_bief_from_geo_file(stfile, 0, 0)
+    wb.set_bief_name(biefname)
+    nb_sect = wb.get_nb_sections()
+    print("nb sections: "+str(nb_sect))
+
+    # hydrogramme file
+    with open(hydfile, encoding = "ISO-8859-1", mode ="r") as hyd:
+        HYD = []
+        lines = hyd.readlines()
+        for line in lines:
+            if (line[0] != '*' and line[0] != '$'):
+                HYD.append([x for x in line.split()])
+
+    # friction file
+    with open(rugfile, encoding = "ISO-8859-1", mode ="r") as lim:
+        RUG = []
+        lines = lim.readlines()
+        for line in lines:
+            if (line[0] != '*' and line[0] != '$'):
+                RUG.append([x for x in line.split()])
+
+    # tarage file
+    with open(limfile, encoding = "ISO-8859-1", mode ="r") as tar:
+        LIM = []
+        lines = tar.readlines()
+        for line in lines:
+            if (line[0] != '*' and line[0] != '$'):
+                LIM.append([x for x in line.split()])
+
+    # cond init file
+    with open(inifile, encoding = "ISO-8859-1", mode ="r") as ini:
+        INI = []
+        lines = ini.readlines()
+        for line in lines:
+            if (line[0] != '*' and line[0] != '$'):
+                INI.append([x for x in line.split()])
+
+    # PAR file
+    with open(parfile, encoding = "ISO-8859-1", mode ="r") as par:
+        PAR = {}
+        lines = par.readlines()
+        for line in lines:
+            l = line.split()
+            if l[0] == 'init_time':
+                t = l[1].split(":")
+                if len(t)>1:
+                    PAR['init_time'] = int(t[0])*24*3600+int(t[1])*3600+int(t[2])*60+int(t[3])
+                else:
+                    PAR['init_time'] = int(t[0])*60
+            elif l[0] == 'final_time':
+                t = l[1].split(":")
+                if len(t)>1:
+                    PAR['final_time'] = int(t[0])*24*3600+int(t[1])*3600+int(t[2])*60+int(t[3])
+                else:
+                    PAR['final_time'] = int(t[0])*60
+            elif l[0] == 'timestep':
+                PAR['timestep'] = float(l[1])
+            elif l[0] == 'timestep_bin':
+                PAR['timestep_bin'] = float(l[1])
+            elif l[0] == 'timestep_tra':
+                PAR['timestep_tra'] = float(l[1])
+            elif l[0] == 'min_height':
+                PAR['min_height'] = float(l[1])
+
+    #os.chdir(current_dir)
+
+    with open("hydrogramme.loi", mode ="w") as hyd:
+        hyd.write("         S\n")
+        for line in HYD:
+            hyd.write(" "+line[0]+" "+line[1]+"\n")
+        if float(HYD[-1][0]) < PAR['final_time']:
+            hyd.write(" "+str(PAR['final_time'])+" "+str(float(HYD[-1][1]))+"\n")
+
+    with open("limnigramme.loi", mode ="w") as lim:
+        lim.write("         S\n")
+        for line in LIM:
+            lim.write(" "+line[0]+" "+line[1]+"\n")
+        if float(LIM[-1][0]) < PAR['final_time']:
+            lim.write(" "+str(PAR['final_time'])+" "+str(float(LIM[-1][1]))+"\n")
+
+    with open("init.lig", mode ="w") as lig:
+        lig.write("RESULTATS CALCUL,DATE :  "+dt.datetime.now().strftime("%d/%m/%y %H:%M"+"\n"))
+        lig.write("FICHIER RESULTAT MASCARET\n")
+        lig.write("-"*71+"\n")
+        lig.write(" IMAX = "+f"{len(INI):4d}"+" NBBIEF=    1\n")
+        lig.write(" I1,I2 =    1    "+str(len(INI))+"\n")
+        lig.write(" X\n")
+        for i in range(int(len(INI)/5)+1):
+            lig.write(" "+"".join([f"{float(INI[j][4]):12.2f}" for j in range(i*5, min(i*5+5, len(INI)))])+"\n")
+        lig.write(" Z\n")
+        for i in range(int(len(INI)/5)+1):
+            lig.write(" "+"".join([f"{float(INI[j][3]):12.3f}" for j in range(i*5, min(i*5+5, len(INI)))])+"\n")
+        lig.write(" Q\n")
+        for i in range(int(len(INI)/5)+1):
+            lig.write(" "+"".join([f"{float(INI[j][2]):12.3f}" for j in range(i*5, min(i*5+5, len(INI)))])+"\n")
+        lig.write(" FIN\n")
+
+    #os.remove("geometrie")
+    wb.output_bief_mascaret("geometrie")
+    pk = [wb.get_pk_section(i+1) for i in range(nb_sect)]
+    print(pk)
+    print(max(pk))
+    print(min(pk))
+
+    out_name = 'FichierCas.xcas'
+    root = ET.Element('fichierCas')
+    pc = ET.SubElement(root, 'parametresCas')
+    pg = ET.SubElement(pc, 'parametresGeneraux')
+    ET.SubElement(pg, 'versionCode').text='3'
+    ET.SubElement(pg, 'code').text = '3'
+    ET.SubElement(pg, 'fichMotsCles').text = out_name
+    ET.SubElement(pg, 'dictionaire').text='dico.txt'
+    ET.SubElement(pg, 'progPrincipal').text='princi.f'
+    ET.SubElement(pg, 'sauveModele').text='false'
+    ET.SubElement(pg, 'fichSauvModele').text='mascaret_exp.tmp'
+    ET.SubElement(pg, 'validationCode').text='false'
+    ET.SubElement(pg, 'typeValidation').text='1'
+    ET.SubElement(pg, 'presenceCasiers').text='false'
+    b = ET.SubElement(pg, 'bibliotheques')
+    ET.SubElement(b, 'bibliotheque').text='mascaretV5P1.a damoV3P0.a'
+    pmp = ET.SubElement(pc, 'parametresModelePhysique')
+    ET.SubElement(pmp, 'perteChargeConf').text='false'
+    ET.SubElement(pmp, 'compositionLits').text='1'
+    ET.SubElement(pmp, 'conservFrotVertical').text='false'
+    ET.SubElement(pmp, 'elevCoteArrivFront').text='0.05'
+    ET.SubElement(pmp, 'interpolLinStrickler').text='false'
+    d = ET.SubElement(pmp, 'debordement')
+    ET.SubElement(d, 'litMajeur').text='false'
+    ET.SubElement(d, 'zoneStock').text='false'
+    pn = ET.SubElement(pc, 'parametresNumeriques')
+    ET.SubElement(pn, 'calcOndeSubmersion').text='false'
+    ET.SubElement(pn, 'decentrement').text='false'
+    ET.SubElement(pn, 'froudeLimCondLim').text='1000.0'
+    ET.SubElement(pn, 'traitImplicitFrot').text='false'
+    ET.SubElement(pn, 'hauteurEauMini').text=str(PAR['min_height'])
+    ET.SubElement(pn, 'implicitNoyauTrans').text='true'
+    ET.SubElement(pn, 'optimisNoyauTrans').text='false'
+    ET.SubElement(pn, 'perteChargeAutoElargissement').text='false'
+    ET.SubElement(pn, 'termesNonHydrostatiques').text='false'
+    ET.SubElement(pn, 'apportDebit').text='0'
+    ET.SubElement(pn, 'attenuationConvection').text='false'
+    pt = ET.SubElement(pc, 'parametresTemporels')
+    ET.SubElement(pt, 'pasTemps').text=str(PAR['timestep'])
+    ET.SubElement(pt, 'tempsInit').text=str(PAR['init_time'])
+    ET.SubElement(pt, 'critereArret').text='1'
+    ET.SubElement(pt, 'nbPasTemps').text='2000'
+    ET.SubElement(pt, 'tempsMax').text=str(PAR['final_time'])
+    ET.SubElement(pt, 'pasTempsVar').text='true'
+    ET.SubElement(pt, 'nbCourant').text='0.8'
+    ET.SubElement(pt, 'coteMax').text='0.0'
+    ET.SubElement(pt, 'abscisseControle').text='0.0'
+    ET.SubElement(pt, 'biefControle').text='1'
+    pgr = ET.SubElement(pc, 'parametresGeometrieReseau')
+    g = ET.SubElement(pgr, 'geometrie')
+    ET.SubElement(g, 'fichier').text='geometrie'
+    ET.SubElement(g, 'format').text='2'
+    ET.SubElement(g, 'profilsAbscAbsolu').text='true'
+    lb = ET.SubElement(pgr, 'listeBranches')
+    ET.SubElement(lb, 'nb').text='1'
+    ET.SubElement(lb, 'numeros').text='1'
+    ET.SubElement(lb, 'abscDebut').text=str(min(pk))
+    ET.SubElement(lb, 'abscFin').text=str(max(pk))
+    ET.SubElement(lb, 'numExtremDebut').text='1'
+    ET.SubElement(lb, 'numExtremFin').text='2'
+    ln = ET.SubElement(pgr, 'listeNoeuds')
+    ET.SubElement(ln, 'nb').text='0'
+    ET.SubElement(ln, 'noeuds')
+    el = ET.SubElement(pgr, 'extrLibres')
+    ET.SubElement(el, 'nb').text='2'
+    ET.SubElement(el, 'num').text='1 2'
+    ET.SubElement(el, 'numExtrem').text='1 2'
+    noms = ET.SubElement(el, 'noms')
+    ET.SubElement(noms, 'string').text='limite1'
+    ET.SubElement(noms, 'string').text='limite2'
+    ET.SubElement(el, 'typeCond').text='1 2'
+    ET.SubElement(el, 'numLoi').text='1 2'
+    pc2 = ET.SubElement(pc, 'parametresConfluents')
+    ET.SubElement(pc2, 'nbConfluents').text='0'
+    ET.SubElement(pc2, 'confluents')
+    pcm = ET.SubElement(pc, 'parametresPlanimetrageMaillage')
+    ET.SubElement(pcm, 'methodeMaillage').text='1'
+    planim = ET.SubElement(pcm, 'planim')
+    ET.SubElement(planim, 'nbPas').text='101'
+    ET.SubElement(planim, 'nbZones').text='1'
+    ET.SubElement(planim, 'valeursPas').text='0.1'
+    ET.SubElement(planim, 'num1erProf').text='1'
+    ET.SubElement(planim, 'numDerProf').text=str(nb_sect)
+    maillage = ET.SubElement(pcm, 'maillage')
+    ET.SubElement(maillage, 'modeSaisie').text='2'
+    ET.SubElement(maillage, 'sauvMaillage').text='false'
+    maillageClavier = ET.SubElement(maillage, 'maillageClavier')
+    ET.SubElement(maillageClavier, 'nbSections').text='0'
+    ET.SubElement(maillageClavier, 'nbPlages').text='1'
+    ET.SubElement(maillageClavier, 'num1erProfPlage').text='1'
+    ET.SubElement(maillageClavier, 'numDerProfPlage').text=str(nb_sect)
+    ET.SubElement(maillageClavier, 'pasEspacePlage').text='10.0'
+    ET.SubElement(maillageClavier, 'nbZones').text='0'
+    ps = ET.SubElement(pc, 'parametresSingularite')
+    ET.SubElement(ps, 'nbSeuils').text='0'
+    pad = ET.SubElement(pc, 'parametresApportDeversoirs')
+    pc3 = ET.SubElement(pc, 'parametresCalage')
+    frt = ET.SubElement(pc3, 'frottement')
+    ET.SubElement(frt, 'loi').text='1'
+    ET.SubElement(frt, 'nbZone').text=str(len(RUG))
+    ET.SubElement(frt, 'numBranche').text=' '.join([i[1] for i in RUG])
+    ET.SubElement(frt, 'absDebZone').text=' '.join([i[2] for i in RUG])
+    ET.SubElement(frt, 'absFinZone').text=' '.join([i[3] for i in RUG])
+    ET.SubElement(frt, 'coefLitMin').text=' '.join([i[4] for i in RUG])
+    ET.SubElement(frt, 'coefLitMaj').text=' '.join([i[5] for i in RUG])
+    zst = ET.SubElement(pc3, 'zoneStockage')
+    ET.SubElement(zst, 'nbProfils').text='0'
+    ET.SubElement(zst, 'numProfil').text='-0'
+    ET.SubElement(zst, 'limGauchLitMaj').text='-0'
+    ET.SubElement(zst, 'limDroitLitMaj').text='-0'
+    plh = ET.SubElement(pc, 'parametresLoisHydrauliques')
+    ET.SubElement(plh, 'nb').text='2'
+    lois = ET.SubElement(plh, 'lois')
+    spl = ET.SubElement(lois, 'structureParametresLoi')
+    ET.SubElement(spl, 'nom').text='loi_1_hydrogramme'
+    ET.SubElement(spl, 'type').text='1'
+    donnees = ET.SubElement(spl, 'donnees')
+    ET.SubElement(donnees, 'modeEntree').text='1'
+    ET.SubElement(donnees, 'fichier').text='hydrogramme.loi'
+    ET.SubElement(donnees, 'uniteTps').text='-0'
+    ET.SubElement(donnees, 'nbPoints').text='-0'
+    ET.SubElement(donnees, 'nbDebitsDifferents').text='-0'
+    spl2 = ET.SubElement(lois, 'structureParametresLoi')
+    ET.SubElement(spl2, 'nom').text='loi_2_limnigramme'
+    ET.SubElement(spl2, 'type').text='2'
+    donnees = ET.SubElement(spl2, 'donnees')
+    ET.SubElement(donnees, 'modeEntree').text='1'
+    ET.SubElement(donnees, 'fichier').text='limnigramme.loi'
+    ET.SubElement(donnees, 'uniteTps').text='-0'
+    ET.SubElement(donnees, 'nbPoints').text='-0'
+    ET.SubElement(donnees, 'nbDebitsDifferents').text='-0'
+    pci = ET.SubElement(pc, 'parametresConditionsInitiales')
+    re = ET.SubElement(pci, 'repriseEtude')
+    ET.SubElement(re, 'repriseCalcul').text='false'
+    le = ET.SubElement(pci, 'ligneEau')
+    ET.SubElement(le, 'LigEauInit').text='true'
+    ET.SubElement(le, 'modeEntree').text='1'
+    ET.SubElement(le, 'fichLigEau').text='init.lig'
+    ET.SubElement(le, 'formatFichLig').text='2'
+    ET.SubElement(le, 'nbPts').text='-0'
+    pir = ET.SubElement(pc, 'parametresImpressionResultats')
+    ET.SubElement(pir, 'titreCalcul').text='Etude hydraulique1d'
+    impression = ET.SubElement(pir, 'impression')
+    ET.SubElement(impression, 'impressionGeometrie').text='false'
+    ET.SubElement(impression, 'impressionPlanimetrage').text='false'
+    ET.SubElement(impression, 'impressionReseau').text='false'
+    ET.SubElement(impression, 'impressionLoiHydraulique').text='false'
+    ET.SubElement(impression, 'impressionligneEauInitiale').text='false'
+    ET.SubElement(impression, 'impressionCalcul').text='false'
+    ps = ET.SubElement(pir, 'pasStockage')
+    ET.SubElement(ps, 'premPasTpsStock').text='1'
+    ET.SubElement(ps, 'pasStock').text=str(int(PAR['timestep_bin']/PAR['timestep']))
+    ET.SubElement(ps, 'pasImpression').text=str(int(PAR['timestep_tra']/PAR['timestep']))
+    results = ET.SubElement(pir, 'resultats')
+    ET.SubElement(results, 'fichResultat').text='mascaret_exp.opt'
+    ET.SubElement(results, 'postProcesseur').text='2'
+    listing = ET.SubElement(pir, 'listing')
+    ET.SubElement(listing, 'fichListing').text='mascaret_exp.lis'
+    reprise = ET.SubElement(pir, 'fichReprise')
+    ET.SubElement(reprise, 'fichRepriseEcr').text='mascaret_exp.rep'
+    rub = ET.SubElement(pir, 'rubens')
+    ET.SubElement(rub, 'ecartInterBranch').text='1.0'
+    stockage = ET.SubElement(pir, 'stockage')
+    ET.SubElement(stockage, 'option').text='1'
+    ET.SubElement(stockage, 'nbSite').text='0'
+    pvc = ET.SubElement(pc, 'parametresVariablesCalculees')
+    ET.SubElement(pvc, 'variablesCalculees').text="false false false false false false false false false false false false false false false"
+
+    pvs = ET.SubElement(pc, 'parametresVariablesStockees')
+    ET.SubElement(pvs, 'variablesStockees').text="true false false false false true true true false false false false false false false false false false false true false false true false false false false false false false false false false false false false false false false false false false"
+
+    tree = ET.ElementTree(root)
+    xmlstr = ET.tostring(root, encoding='unicode', pretty_print=True)
+    tree.write(out_name)
+    print("fin du programme")
+
+    parser = ET.XMLParser(remove_blank_text=True)
+    tree = ET.parse(out_name, parser)
+    tree.write(out_name, pretty_print=True)
+
+
+if __name__ == "__main__":
+
+    current_dir = os.getcwd()
+    os.chdir('/home/theophile.terraz/Codes/mage/src')
+    spec = imp.spec_from_file_location("wb", "./wrapper_bief.py")
+    wb = imp.module_from_spec(spec)
+    spec.loader.exec_module(wb)
+    os.chdir(current_dir)
+
+    print( 'Number of arguments:', len(sys.argv), 'arguments.')
+    print( 'Argument List:', str(sys.argv))
+    mage_to_mascaret(sys.argv[1])
+
+
+

src/Scripts/mascaret_to_mage.py

@@ -0,0 +1,99 @@
+#!/bin/env python3
+
+import sys
+import importlib.util as imp
+import os
+import numpy as np
+
+def lire_opt(filename, res):
+    with open(filename, encoding = "ISO-8859-1", mode ="r") as f:
+        variables = ['"t"','"Bief"','"Section"','"Pk"']
+        lines = f.readlines()
+        for start,line in enumerate(lines):
+            print("line n "+str(start)+" : ",line)
+            if line == "[variables]\n": continue
+            if line == "[resultats]\n": break
+            val = line.split(';')
+            variables.append(val[1])
+            if val[1] == '"ZREF"': izref = start+3
+            if val[1] == '"Q"': iq = start+3
+            if val[1] == '"Z"': iz = start+3
+        print ("variables : "+str(variables))
+
+        #resultats
+        res.mage_version = 83
+        # first pass to count sect and biefs
+        prev_timestep = float(lines[start+1].split(';')[0])
+        for line in lines[start+1:]:
+            ls = line.split(';')
+            t = float(ls[0])
+            if prev_timestep != t : break
+            ibief = int(ls[1].strip('"'))
+            isect = int(ls[2].strip('"'))
+            pk = float(ls[3])
+            if ibief > res.ibmax:
+                res.ibmax += 1
+                res.is1.append(isect)
+                res.is2.append(isect)
+            if isect > res.ismax:
+                res.ismax += 1
+                res.xgeo.append(pk)
+                res.ygeo.append(0.0)
+                res.zfd.append(float(ls[izref]))
+                res.ybas.append(0.0)
+            if isect > res.is2[ibief-1]:
+                res.is2[ibief-1] = isect
+            if isect < res.is1[ibief-1]:
+                res.is1[ibief-1] = isect
+
+        print(" nb sections : "+str(res.ismax))
+
+        # first pass to get the data
+        prev_bief = 0
+        prev_sect = 0
+        z = np.zeros(res.ismax, dtype=np.float32)
+        q = np.zeros(res.ismax, dtype=np.float32)
+        isect = 0
+        count = np.array([1],dtype=np.int32)
+        bZ = bytearray('Z'.encode())
+        bQ = bytearray('Q'.encode())
+        for line in lines[start+1:]:
+            ls = line.split(';')
+            t = float(ls[0])
+            ibief = int(ls[1].strip('"'))
+            isect = int(ls[2].strip('"'))
+            if prev_timestep != t :
+                res.values['Z'].append(prev_timestep, z)
+                res.values['Q'].append(prev_timestep, q)
+                count[0] = 4 + 8 + 1 + 8*len(z)
+                res.raw_data.append(count)
+                res.raw_data.append(np.array([len(z)],dtype=np.int32))
+                res.raw_data.append(np.array([prev_timestep],dtype=np.float64))
+                res.raw_data.append(np.array(bZ,dtype=np.byte))
+                res.raw_data.append(z)
+                res.raw_data.append(count)
+                res.raw_data.append(count)
+                res.raw_data.append(np.array([len(q)],dtype=np.int32))
+                res.raw_data.append(np.array([prev_timestep],dtype=np.float64))
+                res.raw_data.append(np.array(bQ,dtype=np.byte))
+                res.raw_data.append(q)
+                res.raw_data.append(count)
+                prev_timestep = t
+            z[isect-1] = float(ls[iz])
+            q[isect-1] = float(ls[iq])
+
+
+if __name__ == "__main__":
+
+    current_dir = os.getcwd()
+    os.chdir('/home/theophile.terraz/Codes/mage/src')
+    spec = imp.spec_from_file_location("me", "./mage_extraire.py")
+    me = imp.module_from_spec(spec)
+    spec.loader.exec_module(me)
+    os.chdir(current_dir)
+
+    print( 'Number of arguments:', len(sys.argv), 'arguments.')
+    print( 'Argument List:', str(sys.argv))
+    res = me.data()
+    lire_opt(sys.argv[1], res)
+    res.write_bin_8(sys.argv[2][0:-4])

src/Scripts/plot_3DST.py

@@ -1,68 +0,0 @@
-# plot_3DST.py -- Pamhyr
-# Copyright (C) 2023  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 -*-
-
-# a lancer depuis src
-import sys
-from matplotlib import pyplot as plt
-from Model.Geometry.Reach import Reach
-from numpy import mean
-
-def set_axes_equal(ax):
-    '''Make axes of 3D plot have equal scale so that spheres appear as spheres,
-    cubes as cubes, etc..  This is one possible solution to Matplotlib's
-    ax.set_aspect('equal') and ax.axis('equal') not working for 3D.
-
-    Input
-      ax: a matplotlib axis, e.g., as output from plt.gca().
-    '''
-
-    x_limits = ax.get_xlim3d()
-    y_limits = ax.get_ylim3d()
-    z_limits = ax.get_zlim3d()
-
-    x_range = abs(x_limits[1] - x_limits[0])
-    x_middle = mean(x_limits)
-    y_range = abs(y_limits[1] - y_limits[0])
-    y_middle = mean(y_limits)
-    z_range = abs(z_limits[1] - z_limits[0])
-    z_middle = mean(z_limits)
-
-    # The plot bounding box is a sphere in the sense of the infinity
-    # norm, hence I call half the max range the plot radius.
-    plot_radius = 0.5*max([x_range, y_range, z_range])
-
-    ax.set_xlim3d([x_middle - plot_radius, x_middle + plot_radius])
-    ax.set_ylim3d([y_middle - plot_radius, y_middle + plot_radius])
-    ax.set_zlim3d([z_middle - 0.1*plot_radius, z_middle + 0.1*plot_radius])
-
-st_file = sys.argv[1]
-my_reach = Reach(None)
-my_reach.import_geometry(st_file)
-my_reach.compute_guidelines()
-
-ax = plt.figure().add_subplot(projection="3d")
-for x, y, z in zip(my_reach.get_x(), my_reach.get_y(), my_reach.get_z()):
-    ax.plot(x, y, z, color='r', lw=1.)
-for x, y, z in zip(my_reach.get_guidelines_x(), my_reach.get_guidelines_y(), my_reach.get_guidelines_z()):
-    ax.plot(x, y, z, color='b', lw=1.)
-ax.set_xlabel('X')
-ax.set_ylabel('Y')
-ax.set_zlabel('Z')
-plt.tight_layout()
-set_axes_equal(ax)
-plt.show()

src/Solver/ASolver.py

@@ -25,7 +25,7 @@ try:
     # Installation allow Unix-like signal
     from signal import SIGTERM, SIGSTOP, SIGCONT
     _signal = True
-except:
+except Exception:
     _signal = False
 
 from enum import Enum
@@ -37,12 +37,14 @@ from Model.Results.River.River import River, Reach, Profile
 
 logger = logging.getLogger()
 
+
 class STATUS(Enum):
     NOT_LAUNCHED = -1
     STOPED = 0
     RUNNING = 1
     PAUSED = 5
 
+
 class AbstractSolver(object):
     _type = ""
 
@@ -57,17 +59,6 @@ class AbstractSolver(object):
         self._name = name
         self._description = ""
 
-        self._path_input = ""
-        self._path_solver = ""
-        self._path_output = ""
-
-        self._cmd_input = ""
-        self._cmd_solver = ""
-        self._cmd_output = ""
-
-        self._process = None
-        self._output = None
-
         # Last study running
         self._study = None
 
@@ -90,7 +81,6 @@ class AbstractSolver(object):
             ("all_init_time", "000:00:00:00"),
             ("all_final_time", "999:99:00:00"),
             ("all_timestep", "300.0"),
-            ("all_command_line_arguments", ""),
         ]
 
         return lst
@@ -131,6 +121,9 @@ class AbstractSolver(object):
     def is_stoped(self):
         return self._status == STATUS.STOPED
 
+    def has_results_loaded(self):
+        self._status = STATUS.NOT_LAUNCHED
+
     @name.setter
     def name(self, name):
         self._name = name
@@ -139,18 +132,6 @@ class AbstractSolver(object):
     def description(self, description):
         self._description = description
 
-    def set_input(self, path, cmd):
-        self._path_input = path
-        self._cmd_input = cmd
-
-    def set_solver(self, path, cmd):
-        self._path_solver = path
-        self._cmd_solver = cmd
-
-    def set_output(self, path, cmd):
-        self._path_output = path
-        self._cmd_output = cmd
-
     ##########
     # Export #
     ##########
@@ -158,33 +139,6 @@ class AbstractSolver(object):
     def export(self, study, repertory, qlog=None):
         raise NotImplementedMethodeError(self, self.export)
 
-    def cmd_args(self, study):
-        """Return solver command line arguments list
-
-        Returns:
-            Command line arguments list
-        """
-        params = study.river.get_params(self.type)
-        args = params.get_by_key("all_command_line_arguments")
-
-        return args.split(" ")
-
-    def input_param(self):
-        """Return input command line parameter(s)
-
-        Returns:
-            Returns input parameter(s) string
-        """
-        raise NotImplementedMethodeError(self, self.input_param)
-
-    def log_file(self):
-        """Return log file name
-
-        Returns:
-            Returns log file name as string
-        """
-        raise NotImplementedMethodeError(self, self.log_file)
-
     ###########
     # RESULTS #
     ###########
@@ -198,190 +152,17 @@ class AbstractSolver(object):
     # Run #
     #######
 
-    def _install_dir(self):
+    def run(self, study):
-        return os.path.abspath(
+        raise NotImplementedMethodeError(self, self.run)
-            os.path.join(
-                os.path.dirname(__file__),
-                "..", ".."
-            )
-        )
-
-    def _format_command(self, study, cmd, path = ""):
-        """Format command line
-
-        Args:
-            cmd: The command line
-            path: Optional path string (replace @path in cmd)
-
-        Returns:
-            The executable and list of arguments
-        """
-        # HACK: Works in most case... Trust me i'm an engineer
-        cmd = cmd.replace("@install_dir", self._install_dir())
-        cmd = cmd.replace("@path", path.replace(" ", "\ "))
-        cmd = cmd.replace("@input", self.input_param())
-        cmd = cmd.replace("@dir", self._process.workingDirectory())
-        cmd = cmd.replace("@args", " ".join(self.cmd_args(study)))
-
-        logger.debug(f"! {cmd}")
-
-        if cmd[0] == "\"":
-            # Command line executable path is between " char
-            cmd = cmd.split("\"")
-            exe = cmd[1].replace("\ ", " ")
-            args = list(
-                filter(
-                    lambda s: s != "",
-                    "\"".join(cmd[2:]).split(" ")[1:]
-                )
-            )
-        else:
-            # We suppose the command line executable path as no space char
-            cmd = cmd.replace("\ ", "&_&").split(" ")
-            exe = cmd[0].replace("&_&", " ")
-            args = list(
-                filter(
-                    lambda s: s != "",
-                    map(lambda s: s.replace("&_&", "\ "), cmd[1:])
-                )
-            )
-
-        logger.info(f"! {exe} {args}")
-        return exe, args
-
-    def run_input_data_fomater(self, study):
-        if self._cmd_input == "":
-            self._run_next(study)
-            return True
-
-        cmd = self._cmd_input
-        exe, args = self._format_command(study, cmd, self._path_input)
-
-        if not os.path.exists(exe):
-            error = f"[ERROR] Path {exe} do not exists"
-            logger.info(error)
-            return error
-
-        self._process.start(
-            exe, args,
-        )
-
-        return True
-
-    def run_solver(self, study):
-        if self._cmd_solver == "":
-            self._run_next(study)
-            return True
-
-        cmd = self._cmd_solver
-        exe, args = self._format_command(study, cmd, self._path_solver)
-
-        if not os.path.exists(exe):
-            error = f"[ERROR] Path {exe} do not exists"
-            logger.info(error)
-            return error
-
-        self._process.start(
-            exe, args,
-        )
-
-        self._status = STATUS.RUNNING
-        return True
-
-    def run_output_data_fomater(self, study):
-        if self._cmd_output == "":
-            self._run_next(study)
-            return True
-
-        cmd = self._cmd_output
-        exe, args = self._format_command(study, cmd, self._path_output)
-
-        if not os.path.exists(exe):
-            error = f"[ERROR] Path {exe} do not exists"
-            logger.info(error)
-            return error
-
-        self._process.start(
-            exe, args,
-        )
-
-        return True
-
-    def _data_ready(self):
-        s = self._process.readAll().data().decode()
-        if self._output is not None:
-            for x in s.split('\n'):
-                self._output.put(x)
-
-    def _run_next(self, study):
-        self._step += 1
-        if self._step < len(self._runs):
-            res = self._runs[self._step](study)
-            if res is not True:
-                self._output.put(res)
-        else:
-            self._status = STATUS.STOPED
-
-    def _finished(self, study, exit_code, exit_status):
-        if self._output is not None:
-            self._output.put(exit_code)
-
-        self._run_next(study)
-
-    def run(self, study, process = None, output_queue = None):
-        if process is not None:
-            self._process = process
-        if output_queue is not None:
-            self._output = output_queue
-
-        self._process.readyRead.connect(self._data_ready)
-        self._process.finished.connect(lambda c, s: self._finished(study, c, s))
-
-        self._runs = [
-            self.run_input_data_fomater,
-            self.run_solver,
-            self.run_output_data_fomater,
-        ]
-        self._step = 0
-        # Run first step
-        res = self._runs[0](study)
-        if res is not True:
-            self._output.put(res)
 
     def kill(self):
-        if self._process is None:
+        raise NotImplementedMethodeError(self, self.kill)
-            return True
-
-        self._process.kill()
-        self._status = STATUS.STOPED
-        return True
 
     def start(self, study, process=None):
-        if _signal:
+        raise NotImplementedMethodeError(self, self.start)
-            # Solver is PAUSED, so continue execution
-            if self._status == STATUS.PAUSED:
-                os.kill(self._process.pid(), SIGCONT)
-                self._status = STATUS.RUNNING
-                return True
-
-        self.run(study, process)
-        return True
 
     def pause(self):
-        if _signal:
+        raise NotImplementedMethodeError(self, self.pause)
-            if self._process is None:
-                return False
-
-            # Send SIGSTOP to PAUSED solver
-            os.kill(self._process.pid(), SIGSTOP)
-            self._status = STATUS.PAUSED
-            return True
-        return False
 
     def stop(self):
-        if self._process is None:
+        raise NotImplementedMethodeError(self, self.stop)
-            return False
-
-        self._process.terminate()
-        self._status = STATUS.STOPED
-        return True

src/Solver/CommandLine.py

@@ -0,0 +1,324 @@
+# CommandLine.py -- Pamhyr
+# Copyright (C) 2023  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import os
+import logging
+
+from tools import timer, parse_command_line
+
+try:
+    # Installation allow Unix-like signal
+    from signal import SIGTERM, SIGSTOP, SIGCONT
+    _signal = True
+except Exception:
+    _signal = False
+
+from enum import Enum
+
+from Model.Except import NotImplementedMethodeError
+
+from Model.Results.Results import Results
+from Model.Results.River.River import River, Reach, Profile
+
+from Solver.ASolver import AbstractSolver, STATUS
+
+logger = logging.getLogger()
+
+
+class CommandLineSolver(AbstractSolver):
+    _type = ""
+
+    def __init__(self, name):
+        super(CommandLineSolver, self).__init__(name)
+
+        self._current_process = None
+        self._status = STATUS.NOT_LAUNCHED
+
+        self._path_input = ""
+        self._path_solver = ""
+        self._path_output = ""
+
+        self._cmd_input = ""
+        self._cmd_solver = ""
+        self._cmd_output = ""
+
+        self._process = None
+        self._output = None
+
+        # Last study running
+        self._study = None
+
+    @classmethod
+    def default_parameters(cls):
+        lst = super(CommandLineSolver, cls).default_parameters()
+
+        lst += [
+            ("all_command_line_arguments", ""),
+        ]
+
+        return lst
+
+    def set_input(self, path, cmd):
+        self._path_input = path
+        self._cmd_input = cmd
+
+    def set_solver(self, path, cmd):
+        self._path_solver = path
+        self._cmd_solver = cmd
+
+    def set_output(self, path, cmd):
+        self._path_output = path
+        self._cmd_output = cmd
+
+    ##########
+    # Export #
+    ##########
+
+    def cmd_args(self, study):
+        """Return solver command line arguments list
+
+        Returns:
+            Command line arguments list
+        """
+        params = study.river.get_params(self.type)
+        args = params.get_by_key("all_command_line_arguments")
+
+        return args.split(" ")
+
+    def input_param(self):
+        """Return input command line parameter(s)
+
+        Returns:
+            Returns input parameter(s) string
+        """
+        raise NotImplementedMethodeError(self, self.input_param)
+
+    def output_param(self):
+        """Return output command line parameter(s)
+
+        Returns:
+            Returns output parameter(s) string
+        """
+        raise NotImplementedMethodeError(self, self.output_param)
+
+    def log_file(self):
+        """Return log file name
+
+        Returns:
+            Returns log file name as string
+        """
+        raise NotImplementedMethodeError(self, self.log_file)
+
+    #######
+    # Run #
+    #######
+
+    def _install_dir(self):
+        return os.path.abspath(
+            os.path.join(
+                os.path.dirname(__file__),
+                "..", "..", ".."
+            )
+        )
+
+    def _format_command(self, study, cmd, path=""):
+        """Format command line
+
+        Args:
+            cmd: The command line
+            path: Optional path string (replace @path in cmd)
+
+        Returns:
+            The executable and list of arguments
+        """
+        cmd = cmd.replace("@install_dir", self._install_dir())
+        cmd = cmd.replace("@path", "\"" + path + "\"")
+        cmd = cmd.replace("@input", self.input_param())
+        cmd = cmd.replace("@output", self.output_param())
+        cmd = cmd.replace("@dir", self._process.workingDirectory())
+        cmd = cmd.replace("@args", " ".join(self.cmd_args(study)))
+
+        logger.debug(f"! {cmd}")
+
+        words = parse_command_line(cmd)
+        exe = words[0]
+        args = words[1:]
+
+        logger.info(f"! {exe} {args}")
+        return exe, args
+
+    def run_input_data_fomater(self, study):
+        if self._cmd_input == "":
+            self._run_next(study)
+            return True
+
+        cmd = self._cmd_input
+        exe, args = self._format_command(study, cmd, self._path_input)
+
+        if not os.path.exists(exe):
+            error = f"[ERROR] Path {exe} do not exists"
+            logger.warning(error)
+            return error
+
+        self._process.start(
+            exe, args,
+        )
+        self._process.waitForStarted()
+
+        return True
+
+    def run_solver(self, study):
+        if self._cmd_solver == "":
+            self._run_next(study)
+            return True
+
+        cmd = self._cmd_solver
+        exe, args = self._format_command(study, cmd, self._path_solver)
+
+        if not os.path.exists(exe):
+            error = f"[ERROR] Path {exe} do not exists"
+            logger.warning(error)
+            return error
+
+        self._process.start(
+            exe, args,
+        )
+        self._process.waitForStarted()
+
+        self._status = STATUS.RUNNING
+        return True
+
+    def run_output_data_fomater(self, study):
+        if self._cmd_output == "":
+            self._run_next(study)
+            return True
+
+        cmd = self._cmd_output
+        exe, args = self._format_command(study, cmd, self._path_output)
+
+        if not os.path.exists(exe):
+            error = f"[ERROR] Path {exe} do not exists"
+            logger.warning(error)
+            return error
+
+        self._process.start(
+            exe, args,
+        )
+        self._process.waitForStarted()
+
+        return True
+
+    def _data_ready(self):
+        # Read process output and put lines in queue
+        s = self._process.readAll().data().decode()
+
+        if self._output is not None:
+            for x in s.split('\n'):
+                self._output.put(x)
+
+    def _finished(self, study, exit_code, exit_status):
+        if self._output is not None:
+            self._output.put(exit_code)
+
+        logger.debug(
+            "Process finished with " +
+            f"code: {exit_code}, status: {exit_status}"
+        )
+
+        self._run_next(study)
+
+    def _run_next(self, study):
+        self._step += 1
+
+        if self._step >= len(self._runs):
+            self._status = STATUS.STOPED
+            return
+
+        fn = self._runs[self._step]
+        res = fn(study)
+
+        if res is not True:
+            self._output.put(res)
+
+    def run(self, study, process=None, output_queue=None):
+        self._study = study
+
+        # Replace old values if needed
+        if process is not None:
+            self._process = process
+        if output_queue is not None:
+            self._output = output_queue
+
+        # Connect / reconnect signal
+        self._process.readyRead.connect(self._data_ready)
+        self._process.finished.connect(
+            lambda c, s: self._finished(study, c, s)
+        )
+
+        # Prepare running step
+        self._runs = [
+            self.run_input_data_fomater,
+            self.run_solver,
+            self.run_output_data_fomater,
+        ]
+        self._step = 0
+
+        self._status = STATUS.RUNNING
+
+        # Run first step
+        res = self._runs[0](study)
+        if res is not True:
+            self._output.put(res)
+
+    def kill(self):
+        if self._process is None:
+            return True
+
+        self._process.kill()
+        self._status = STATUS.STOPED
+        return True
+
+    def start(self, study, process=None):
+        if _signal:
+            # Solver is PAUSED, so continue execution
+            if self._status == STATUS.PAUSED:
+                os.kill(self._process.pid(), SIGCONT)
+                self._status = STATUS.RUNNING
+                return True
+
+        self.run(study, process)
+        return True
+
+    def pause(self):
+        if _signal:
+            if self._process is None:
+                return False
+
+            # Send SIGSTOP to PAUSED solver
+            os.kill(self._process.pid(), SIGSTOP)
+            self._status = STATUS.PAUSED
+            return True
+        return False
+
+    def stop(self):
+        if self._process is None:
+            return False
+
+        self._process.terminate()
+        self._status = STATUS.STOPED
+        return True

src/Solver/GenericSolver.py

@@ -16,11 +16,10 @@
 
 # -*- coding: utf-8 -*-
 
-from Solver.ASolver import (
+from Solver.CommandLine import CommandLineSolver
-    AbstractSolver, STATUS
-)
 
-class GenericSolver(AbstractSolver):
+
+class GenericSolver(CommandLineSolver):
     _type = "generic"
 
     def __init__(self, name):

src/Solver/Mage.py

@@ -20,9 +20,9 @@ import os
 import logging
 import numpy as np
 
-from tools import timer
+from tools import timer, trace
 
-from Solver.ASolver import AbstractSolver
+from Solver.CommandLine import CommandLineSolver
 from Checker.Mage import MageNetworkGraphChecker
 
 from Model.Results.Results import Results
@@ -30,16 +30,18 @@ from Model.Results.River.River import River, Reach, Profile
 
 logger = logging.getLogger()
 
+
 def mage_file_open(filepath, mode):
     f = open(filepath, mode)
 
     if "w" in mode:
         # Write header
-        f.write("* This file is generate by PAMHYR, please don't modify\n")
+        f.write("* This file is generated by PAMHYR, please don't modify\n")
 
     return f
 
-class Mage(AbstractSolver):
+
+class Mage(CommandLineSolver):
     _type = "mage"
 
     def __init__(self, name):
@@ -51,7 +53,6 @@ class Mage(AbstractSolver):
         self._cmd_solver = "@path @input -o @output"
         self._cmd_output = ""
 
-
     @classmethod
     def default_parameters(cls):
         lst = super(Mage, cls).default_parameters()
@@ -80,6 +81,7 @@ class Mage(AbstractSolver):
             ("mage_compute_reach_volume_balance", "y"),
             ("mage_max_reach_volume_balance", "0.001"),
             ("mage_min_reach_volume_to_check", "1000.0"),
+            ("mage_init_internal", " "),
         ]
 
         return lst
@@ -98,16 +100,20 @@ class Mage(AbstractSolver):
     ##########
 
     def cmd_args(self, study):
-        l = super(Mage, self).cmd_args(study)
+        lst = super(Mage, self).cmd_args(study)
 
-        l.append("-r")
+        lst.append("-r")
 
-        return l
+        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"
@@ -120,7 +126,6 @@ class Mage(AbstractSolver):
             qlog.put("Export ST file")
 
         os.makedirs(os.path.join(repertory, "net"), exist_ok=True)
-        gra_file = f"{name}.GRA"
 
         # Write header
         edges = study.river.edges()
@@ -136,55 +141,91 @@ class Mage(AbstractSolver):
             if edge._name == "":
                 name = f"Reach_{edge.id}"
 
-            with mage_file_open(os.path.join(repertory, "net", f"{name}.ST"), "w+") as f:
+            with mage_file_open(
+                    os.path.join(repertory, "net", f"{name}.ST"),
+                    "w+"
+            ) as f:
                 files.append(str(os.path.join("net", f"{name}.ST")))
 
                 cnt_num = 1
                 for profile in edge.reach.profiles:
-                    num = f"{cnt_num:>6}"
+                    self._export_ST_profile_header(
-                    c1 = f"{profile.code1:>6}"
+                        f, files, profile, cnt_num
-                    c2 = f"{profile.code2:>6}"
+                    )
-                    t = f"{len(profile.points):>6}"
-                    kp = f"{profile.kp:>13.4f}"
-                    pname = profile.name
-                    if profile.name == "":
-                        pname = f"p{profile.id:>3}".replace(" ", "p")
-                    name = f"{pname}"
-
-                    sediment = ""
-                    if profile.sl is not None:
-                        if not any(filter(lambda f: ".GRA" in f, files)):
-                            files.append(gra_file)
-
-                        nl = len(profile.sl)
-                        sediment = f" {nl:>3}"
-                        for l in profile.sl.layers:
-                            sediment += f" {l.height:>10} {l.d50:>10} {l.sigma:>10} {l.critical_constraint:>10}"
-
-                    f.write(f"{num}{c1}{c2}{t}{kp}  {name} {sediment}\n")
                     cnt_num += 1
 
+                    # Points
                     for point in profile.points:
-                        x = f"{point.x:>13.4f}"
+                        self._export_ST_point_line(
-                        y = f"{point.y:>13.4f}"
+                            f, files, point
-                        z = f"{point.z:>13.4f}"
+                        )
-                        n = f"{point.name:<3}"
-
-                        sediment = ""
-                        prev = point.z
-                        if point.sl is not None:
-                            nl = len(point.sl)
-                            sediment = f"{nl:>3}"
-                            for l in point.sl.layers:
-                                prev = round(prev - l.height, 5)
-                                sediment += f" {prev:>10} {l.d50:>10} {l.sigma:>10} {l.critical_constraint:>10}"
-
-                        f.write(f"{x}{y}{z} {n} {sediment}\n")
 
+                    # Profile last line
                     f.write(f"     999.9990     999.9990     999.9990\n")
 
         return files
 
+    def _export_ST_profile_header(self, wfile, files,
+                                  profile, cnt):
+        num = f"{cnt:>6}"
+        c1 = f"{profile.code1:>6}"
+        c2 = f"{profile.code2:>6}"
+        t = f"{len(profile.points):>6}"
+        kp = f"{profile.kp:>12f}"[0:12]
+        pname = profile.name
+        if profile.name == "":
+            # Generate name from profile id prefixed with
+            # 'p' (and replace space char with '0' char)
+            pname = f"p{profile.id:>3}".replace(" ", "0")
+            name = f"{pname:<19}"
+
+        # Generate sediment additional data if available
+        sediment = ""
+        if profile.sl is not None:
+            if not any(filter(lambda f: ".GRA" in f, files)):
+                files.append(self._gra_file)
+
+            # Number of layers
+            nl = len(profile.sl)
+            sediment = f" {nl:>3}"
+
+            # Layers data
+            for layer in profile.sl.layers:
+                sediment += (
+                    f" {layer.height:>10} {layer.d50:>10} " +
+                    f"{layer.sigma:>10} " +
+                    f"{layer.critical_constraint:>10}"
+                )
+
+        # Profile header line
+        wfile.write(f"{num}{c1}{c2}{t} {kp} {pname} {sediment}\n")
+
+    def _export_ST_point_line(self, wfile, files, point):
+        x = f"{point.x:<12.4f}"[0:12]
+        y = f"{point.y:<12.4f}"[0:12]
+        z = f"{point.z:<12.4f}"[0:12]
+        n = f"{point.name:<3}"
+
+        # Generate sediment additional data if available
+        sediment = ""
+        prev = point.z
+        if point.sl is not None:
+            # Number of layers
+            nl = len(point.sl)
+            sediment = f"{nl:>3}"
+
+            # Layers data
+            for layer in point.sl.layers:
+                prev = round(prev - layer.height, 5)
+                sediment += (
+                    f" {prev:>10} {layer.d50:>10} " +
+                    f"{layer.sigma:>10} " +
+                    f"{layer.critical_constraint:>10}"
+                )
+
+        # Point line
+        wfile.write(f"{x} {y} {z} {n} {sediment}\n")
+
     @timer
     def _export_BC(self, t, bounds, repertory, qlog, name="0"):
         files = []
@@ -228,6 +269,9 @@ class Mage(AbstractSolver):
 
         for tab in ["liquid", "solid", "suspenssion"]:
             for bound in lst.get_tab(tab):
+                if bound.node is None:
+                    continue
+
                 if bound.bctype == "ZD":
                     AVA.append(bound)
                 elif bound.bctype == "TD" or bound.bctype == "PC":
@@ -251,7 +295,10 @@ class Mage(AbstractSolver):
     #     if qlog is not None:
     #         qlog.put(f"Export LAT file")
 
-    #     with mage_file_open(os.path.join(repertory, f"{name}.LAT"), "w+") as f:
+    #     with mage_file_open(
+    #             os.path.join(repertory, f"{name}.LAT"),
+    #             "w+"
+    #     ) as f:
     #         files.append(f"{name}.LAT")
 
     #         name = f"{lateral.node.id:3}".replace(" ", "x")
@@ -328,13 +375,7 @@ class Mage(AbstractSolver):
         with mage_file_open(os.path.join(repertory, f"{name}.INI"), "w+") as f:
             has_ini = False
             id = 1
-            reachs = study.river.edges()
+            reachs = study.river.enable_edges()
-            reachs = list(
-                filter(
-                    lambda e: e.is_enable(),
-                    reachs
-                )
-            )
 
             # TODO put real date...
             f.write(f"$ date en minutes :       0.00\n")
@@ -351,8 +392,8 @@ class Mage(AbstractSolver):
 
                 id_sec = 1
                 for d in data:
-                    IR = f"{id:>3}"
+                    IR = f"{id}"
-                    IS = f"{id_sec:>3}"
+                    IS = f"{id_sec}"
                     discharge = f"{d['discharge']:>10.5f}"
                     elevation = f"{d['elevation']:>11.6f}"
                     kp = f"{d['kp']:>9.2f}"
@@ -366,13 +407,179 @@ class Mage(AbstractSolver):
             files.append(f"{name}.INI")
         return files
 
+    @timer
+    def _export_CAS(self, study, repertory, qlog, name="0"):
+        files = []
+
+        reservoirs = study.river.reservoir.lst
+        if len(reservoirs) == 0:
+            return files
+
+        if qlog is not None:
+            qlog.put("Export CAS file")
+
+        with mage_file_open(os.path.join(repertory, f"{name}.CAS"), "w+") as f:
+            files.append(f"{name}.CAS")
+
+            for reservoir in reservoirs:
+                reservoir.sort()
+                node = reservoir.node
+                name = f"{node.id:3}".replace(" ", "x")
+                f.write(f"* {node.name} ({name}) Reservoir\n")
+                f.write(f"${name}\n")
+                f.write(f"*{'Elev(m)':>9}|{'Area(ha)':>10}\n")
+
+                for d in reservoir.data:
+                    v0 = d[0]
+                    v1 = d[1]
+
+                    f.write(f"{v0:>10.3f}{v1:>10.3f}\n")
+
+        return files
+
+    @timer
+    def _export_SIN(self, study, repertory, qlog, name="0"):
+        files = []
+
+        sin_dict = {
+            "ND": "*",
+            "S1": "D", "S2": "T", "S3": "T",
+            "OR": "O", "OC": "B", "OV": "F",
+            "V1": "V", "V2": "W",
+            "BO": "A",
+            "UD": "X",
+            "PO": "P",
+        }
+
+        hydraulic_structures = study.river.hydraulic_structures.lst
+        if len(hydraulic_structures) == 0:
+            return files
+
+        if qlog is not None:
+            qlog.put("Export SIN file")
+
+        with mage_file_open(os.path.join(repertory, f"{name}.SIN"), "w+") as f:
+            files.append(f"{name}.SIN")
+
+            for hs in hydraulic_structures:
+                if not hs.input_reach.is_enable():
+                    continue
+
+                f.write(
+                    '* ouvrage au pk ' +
+                    f"{hs.input_kp:>12.1f}" + ' ' +
+                    hs.name + '\n'
+                )
+
+                for bhs in hs.basic_structures:
+                    reach_id = study.river.get_edge_id(hs.input_reach) + 1
+                    param_str = ' '.join(
+                        [
+                            f'{p:>10.3f}'
+                            for p in self._export_SIN_parameters(bhs)
+                        ]
+                    )
+
+                    f.write(
+                        f"{sin_dict[bhs._type]} " +
+                        f"{reach_id} {hs.input_kp:>12.3f} {param_str} " +
+                        f"{bhs.name}\n"
+                    )
+
+        return files
+
+    def _export_SIN_parameters(self, bhs):
+        res = [9999.999] * 5
+
+        if len(bhs) == 5:
+            res = self._export_SIN_parameters_5(bhs)
+        elif len(bhs) == 4:
+            res = self._export_SIN_parameters_4(bhs)
+        elif len(bhs) == 3:
+            res = self._export_SIN_parameters_3(bhs)
+
+        return res
+
+    def _export_SIN_parameters_5(self, bhs):
+        # S2, OR, V1, V2, UD
+        return [
+            bhs._data[0].value,
+            bhs._data[1].value,
+            bhs._data[2].value,
+            bhs._data[3].value,
+            bhs._data[4].value,
+        ]
+
+    def _export_SIN_parameters_4(self, bhs):
+        # S3, OC
+        res = [
+            bhs._data[0].value,
+            bhs._data[1].value,
+            bhs._data[2].value,
+            bhs._data[3].value,
+            0.0,
+        ]
+
+        if bhs._type == "T":    # S3
+            res = [0.0] + res[:-1]
+
+        return res
+
+    def _export_SIN_parameters_3(self, bhs):
+        # S1, BO
+        if bhs._type == "S1":
+            res = [
+                bhs._data[0].value,
+                bhs._data[1].value,
+                0.0,
+                bhs._data[2].value,
+                9999.99,
+            ]
+        else:
+            res = [
+                bhs._data[0].value,
+                bhs._data[1].value,
+                bhs._data[2].value,
+                0.0,
+                0.0,
+            ]
+
+        return res
+
+    @timer
+    def _export_DEV(self, study, repertory, qlog, name="0"):
+        files = []
+
+        if qlog is not None:
+            qlog.put("Export DEV file")
+
+        with mage_file_open(
+                os.path.join(
+                    repertory, f"{name}.DEV"
+                ), "w+"
+        ) as f:
+            reachs = study.river.enable_edges()
+
+            id = 1
+            for reach in reachs:
+                f.write(f"YD{id:3}\n")
+                f.write(f"YG{id:3}\n")
+                id += 1
+            files.append(f"{name}.DEV")
+
+        return files
+
     @timer
     def _export_REP(self, study, repertory, files, qlog, name="0"):
         if qlog is not None:
             qlog.put("Export REP file")
 
         # Write header
-        with mage_file_open(os.path.join(repertory, f"{name}.REP"), "w+") as f:
+        with mage_file_open(
+                os.path.join(
+                    repertory, f"{name}.REP"
+                ), "w+"
+        ) as f:
             f.write("confirmation=non\n")
 
             for file in files:
@@ -391,12 +598,15 @@ class Mage(AbstractSolver):
                 if EXT in ["GRA"]:
                     f.write(f"{EXT} {file}\n")
 
-
     @timer
     def export(self, study, repertory, qlog=None):
         self._study = study
         name = study.name.replace(" ", "_")
 
+        # Define GRA file name
+        self._gra_file = f"{name}.GRA"
+        self._bin_file = f"{name}.BIN"
+
         self._export_ST(study, repertory, qlog, name=name)
 
         return True
@@ -410,8 +620,12 @@ class Mage(AbstractSolver):
 
     @timer
     def results(self, study, repertory, qlog=None, name="0"):
-        results = Results(study = study)
+        results = Results(
-
+            study=study,
+            solver=self,
+            repertory=repertory,
+            name=name,
+        )
         self.read_bin(study, repertory, results, qlog, name=name)
 
         return results
@@ -420,6 +634,7 @@ class Mage(AbstractSolver):
 # MAGE 7 #
 ##########
 
+
 class Mage7(Mage):
     _type = "mage7"
 
@@ -438,6 +653,7 @@ class Mage7(Mage):
 # MAGE 8 #
 ##########
 
+
 class Mage8(Mage):
     _type = "mage8"
 
@@ -476,12 +692,12 @@ class Mage8(Mage):
     ##########
 
     def cmd_args(self, study):
-        l = super(Mage8, self).cmd_args(study)
+        lst = super(Mage8, self).cmd_args(study)
 
         if study.river.has_sediment():
-            l.append("-c=3")
+            lst.append("-c=3")
 
-        return l
+        return lst
 
     @timer
     def _export_PAR(self, study, repertory, qlog=None, name="0"):
@@ -503,8 +719,12 @@ class Mage8(Mage):
                 if name in ["command_line_arguments"]:
                     continue
 
-                if name is "mage_compute_reach_volume_balance":
+                if name == "compute_reach_volume_balance":
-                    value = "O" if value == "y" else "N"
+                    value = "O" if value.lower() == "y" else "N"
+
+                if name == "init_internal":
+                    value = ("p" if value.lower() in ["y", "yes", "true"]
+                             else "")
 
                 f.write(f"{name} {value}\n")
 
@@ -579,20 +799,28 @@ class Mage8(Mage):
 
         return files
 
-
     @timer
     def export(self, study, repertory, qlog=None, name="0"):
         self._study = study
         name = study.name.replace(" ", "_")
 
+        # Define GRA file name
+        self._gra_file = f"{name}.GRA"
+        self._bin_file = f"{name}.BIN"
+
+        # Generate files
         files = []
 
         files = self._export_ST(study, repertory, qlog, name=name)
         files = files + self._export_PAR(study, repertory, qlog, name=name)
         files = files + self._export_NET(study, repertory, qlog, name=name)
-        files = files + self._export_bound_cond(study, repertory, qlog, name=name)
+        files = files + \
+            self._export_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_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
@@ -607,12 +835,17 @@ class Mage8(Mage):
         logger.info(f"read_bin: Start reading '{fname}' ...")
 
         with mage_file_open(fname, "r") as f:
-            newline = lambda: np.fromfile(f, dtype=np.int32, count=1)
+            def newline(): return np.fromfile(f, dtype=np.int32, count=1)
-            endline = lambda: np.fromfile(f, dtype=np.int32, count=1)
+            def endline(): return np.fromfile(f, dtype=np.int32, count=1)
 
-            read_int = lambda size: np.fromfile(f, dtype=np.int32, count=size)
+            def read_int(size): return np.fromfile(
-            read_float = lambda size: np.fromfile(f, dtype=np.float32, count=size)
+                f, dtype=np.int32, count=size)
-            read_float64 = lambda size: np.fromfile(f, dtype=np.float64, count=size)
+
+            def read_float(size): return np.fromfile(
+                f, dtype=np.float32, count=size)
+
+            def read_float64(size): return np.fromfile(
+                f, dtype=np.float64, count=size)
 
             # Meta data (1st line)
             newline()
@@ -686,7 +919,7 @@ class Mage8(Mage):
             # Data
             newline()
 
-            ip_to_r = lambda i: iprofiles[
+            def ip_to_r(i): return iprofiles[
                 next(
                     filter(
                         lambda k: k[0] <= i <= k[1],
@@ -694,14 +927,15 @@ class Mage8(Mage):
                     )
                 )
             ]
-            ip_to_ri = lambda r, i: i - reach_offset[r]
+            def ip_to_ri(r, i): return i - reach_offset[r]
 
             ts = set()
             end = False
             while not end:
                 n = read_int(1)[0]
                 timestamp = read_float64(1)[0]
-                key = bytearray(np.fromfile(f, dtype=np.byte, count=1)).decode()
+                key = bytearray(np.fromfile(
+                    f, dtype=np.byte, count=1)).decode()
                 data = read_float(n)
 
                 logger.debug(f"read_bin: timestamp = {timestamp} sec")
@@ -716,6 +950,13 @@ class Mage8(Mage):
 
                         # Set data for profile RI
                         reach.set(ri, timestamp, key, d)
+                        if key == "Z":
+                            profile = study.river\
+                                           .current_reach()\
+                                           .reach.profile(ri)
+                            ptX, ptY = profile.get_water_limits(d)
+                            reach.set(ri, timestamp, "ptX", ptX)
+                            reach.set(ri, timestamp, "ptY", ptY)
 
                 endline()
                 end = newline().size <= 0
@@ -733,12 +974,17 @@ class Mage8(Mage):
         logger.info(f"read_gra: Start reading '{fname}' ...")
 
         with mage_file_open(fname, "r") as f:
-            newline = lambda: np.fromfile(f, dtype=np.int32, count=1)
+            def newline(): return np.fromfile(f, dtype=np.int32, count=1)
-            endline = lambda: np.fromfile(f, dtype=np.int32, count=1)
+            def endline(): return np.fromfile(f, dtype=np.int32, count=1)
 
-            read_int = lambda size: np.fromfile(f, dtype=np.int32, count=size)
+            def read_int(size): return np.fromfile(
-            read_float = lambda size: np.fromfile(f, dtype=np.float32, count=size)
+                f, dtype=np.int32, count=size)
-            read_float64 = lambda size: np.fromfile(f, dtype=np.float64, count=size)
+
+            def read_float(size): return np.fromfile(
+                f, dtype=np.float32, count=size)
+
+            def read_float64(size): return np.fromfile(
+                f, dtype=np.float64, count=size)
 
             # Meta data (1st line)
             newline()
@@ -753,7 +999,7 @@ class Mage8(Mage):
             logger.debug(f"read_gra: nb_profile = {nb_profile}")
             logger.debug(f"read_gra: mage_version = {mage_version}")
 
-            if mage_version <= 80:
+            if mage_version < 80:
                 msg = (
                     "Read GRA files: " +
                     f"Possible incompatible mage version '{mage_version}', " +
@@ -810,7 +1056,7 @@ class Mage8(Mage):
             endline()
 
             # Data
-            ip_to_r = lambda i: iprofiles[
+            def ip_to_r(i): return iprofiles[
                 next(
                     filter(
                         lambda k: k[0] <= i <= k[1],
@@ -818,63 +1064,74 @@ class Mage8(Mage):
                     )
                 )
             ]
-            ip_to_ri = lambda r, i: i - reach_offset[r]
+            def ip_to_ri(r, i): return i - reach_offset[r]
 
             ts = set()
-            ind = 0
             end = False
 
             newline()
             while not end:
                 n = read_int(1)[0]
                 timestamp = read_float64(1)[0]
+                with_bedload = read_int(1)[0]
+
+                logger.debug(f"read_gra: Number of cross section: {n}")
+                logger.debug(f"read_gra: Timestamp: {timestamp}")
+                logger.debug(f"read_gra: Type of bedload: {with_bedload}")
+
+                endline()
+
+                npts = [1] * n
+                if with_bedload == 1:
+                    newline()
+                    npts = read_int(n)
+                    endline()
+                sum_npts = sum(npts)
+                logger.debug(f"read_gra: Number of points: {sum_npts}")
+
+                newline()
+                nsl = read_int(sum_npts)
+                logger.debug(f"read_gra: Number of sedimentary layers: {nsl}")
+                endline()
+
+                newline()
+                data = read_float64(sum(nsl) * 3)
+                endline()
 
-                logger.debug(f"read_gra: timestamp = {timestamp} sec")
                 ts.add(timestamp)
 
-                endline()
+                i_pts = 0
-
+                i_data = 0
+                # Loop on cross section
                 for i in range(n):
-                    newline()
+                    sec_sl = []
-                    nsl = read_int(1)[0]
-                    endline()
-
-                    # Get current profile id
                     reach = ip_to_r(i)
-                    ri = ip_to_ri(reach, i)
+                    p_i = ip_to_ri(reach, i)
-
-                    if nsl > 1:
-                        logger.warning(
-                            "read_gra: " +
-                            "Multiple sediment layers for one profile " +
-                            "is not implemented yet..."
-                        )
-
-                    for j in range(nsl):
-                        newline()
-                        nl = read_int(1)[0]
-                        endline()
 
+                    # Loop on cross section points
+                    for j in range(npts[i]):
                         sl = []
 
-                        for k in range(nl):
+                        # Loop on sediment layers
-                            newline()
+                        for k in range(nsl[i_pts]):
-                            data = read_float64(3)
+                            h = data[i_data]
-                            endline()
+                            d50 = data[i_data + 1]
-
+                            sigma = data[i_data + 2]
-                            h = data[0]
-                            d50 = data[1]
-                            sigma = data[2]
 
                             sl.append((h, d50, sigma))
+                            i_data += 3
 
-                        reach.set(ri, timestamp, "sl", sl)
+                        i_pts += 1
+                        sec_sl.append(sl)
 
-                ind += 1
+                    reach.set(p_i, timestamp, "sl", sec_sl)
+
+                logger.debug(
+                    f"read_gra: data size = {len(data)} ({i_data} readed)"
+                )
                 end = newline().size <= 0
 
-            logger.debug(reachs[0].profiles[0]._data)
+            results.set("sediment_timestamps", ts)
-            results.set("timestamps", ts)
             logger.info(f"read_gra: ... end with {len(ts)} timestamp read")
 
     @timer

src/Solver/Solvers.py

@@ -24,9 +24,9 @@ from Solver.Mage import Mage7, Mage8
 _translate = QCoreApplication.translate
 
 solver_long_name = {
-    "generic": _translate("Solvers", "Generic"),
+    "generic": "Generic",
-    # "mage7": _translate("Solvers", "Mage version 7"),
+    # "mage7": "Mage v7",
-    "mage8": _translate("Solvers", "Mage version 8"),
+    "mage8": "Mage v8",
 }
 
 solver_type_list = {

src/View/About/Window.py

@@ -19,14 +19,18 @@
 import os
 import logging
 
-from View.ASubWindow import ASubWindow
+from View.Tools.PamhyrWindow import PamhyrDialog
 
 from PyQt5.QtCore import QCoreApplication
 
 _translate = QCoreApplication.translate
 logger = logging.getLogger()
 
-class AboutWindow(ASubWindow):
+
+class AboutWindow(PamhyrDialog):
+    _pamhyr_ui = "about"
+    _pamhyr_name = "About"
+
     def _path_file(self, filename):
         return os.path.abspath(
             os.path.join(
@@ -35,10 +39,14 @@ class AboutWindow(ASubWindow):
             )
         )
 
-
+    def __init__(self, study=None, config=None, parent=None):
-    def __init__(self, title="About", parent=None):
+        super(AboutWindow, self).__init__(
-        super(AboutWindow, self).__init__(name=title, ui="about", parent=parent)
+            title=_translate("About", "About"),
-        self.ui.setWindowTitle(title)
+            study=study,
+            config=config,
+            options=[],
+            parent=parent
+        )
 
         # Version
         with open(self._path_file("VERSION"), "r") as f:

src/View/BoundaryCondition/Edit/Plot.py

@@ -21,27 +21,32 @@ import logging
 from datetime import datetime
 
 from tools import timer, trace
-from View.Plot.APlot import APlot
+from View.Tools.PamhyrPlot import PamhyrPlot
 
 from PyQt5.QtCore import (
     QCoreApplication
 )
 
-from View.BoundaryCondition.Edit.translate import *
+from View.BoundaryCondition.Edit.translate import BCETranslate
 
 _translate = QCoreApplication.translate
 
 logger = logging.getLogger()
 
-class Plot(APlot):
+
-    def __init__(self, canvas=None, data=None,
+class Plot(PamhyrPlot):
-                 mode = "time", toolbar=None):
+    def __init__(self, mode="time", data=None,
+                 trad=None, canvas=None, toolbar=None,
+                 parent=None):
         super(Plot, self).__init__(
             canvas=canvas,
+            trad=trad,
             data=data,
-            toolbar=toolbar
+            toolbar=toolbar,
+            parent=parent
         )
 
+        self._table_headers = self._trad.get_dict("table_headers")
         self._mode = mode
 
     def custom_ticks(self):
@@ -68,8 +73,8 @@ class Plot(APlot):
                 map(
                     lambda v: str(
                         datetime.fromtimestamp(v[0]) - t0
-                    ).split(",")[0]\
+                    ).split(",")[0]
-                    .replace("days", _translate("BoundaryCondition", "days"))\
+                    .replace("days", _translate("BoundaryCondition", "days"))
                     .replace("day", _translate("BoundaryCondition", "day")),
                     fx
                 )
@@ -84,7 +89,6 @@ class Plot(APlot):
 
         self.canvas.axes.set_xticks(ticks=xx, labels=xt, rotation=45)
 
-
     @timer
     def draw(self):
         self.canvas.axes.cla()
@@ -109,10 +113,10 @@ class Plot(APlot):
         # Plot label
         header = self.data.header
         self.canvas.axes.set_xlabel(
-            table_headers[header[0]], color='black', fontsize=10
+            self._table_headers[header[0]], color='black', fontsize=10
         )
         self.canvas.axes.set_ylabel(
-            table_headers[header[1]], color='black', fontsize=10
+            self._table_headers[header[1]], color='black', fontsize=10
         )
 
         self.canvas.axes.autoscale_view(True, True, True)
@@ -124,7 +128,7 @@ class Plot(APlot):
 
     @timer
     def update(self, ind=None):
-        if self._init == False:
+        if not self._init:
             self.draw()
             return
 

src/View/BoundaryCondition/Edit/Table.py

@@ -23,8 +23,6 @@ from datetime import date, time, datetime, timedelta
 
 from tools import trace, timer
 
-from View.ASubWindow import ASubMainWindow, AWidget
-from View.ListedSubWindow import ListedSubWindow
 from View.Tools.PamhyrTable import PamhyrTableModel
 
 from PyQt5.QtCore import (
@@ -46,14 +44,13 @@ from Model.BoundaryCondition.BoundaryConditionTypes import (
 from View.BoundaryCondition.Edit.UndoCommand import (
     SetDataCommand, AddCommand, DelCommand,
     SortCommand, MoveCommand, PasteCommand,
-    DuplicateCommand,
 )
-from View.BoundaryCondition.Edit.translate import *
 
 _translate = QCoreApplication.translate
 
 logger = logging.getLogger()
 
+
 class TableModel(PamhyrTableModel):
     def data(self, index, role):
         if role == Qt.TextAlignmentRole: