RubarBE: notify when attempting to use RubarBE with solid boundary conditions missing

.gitlab-ci.yml

@@ -638,7 +638,7 @@ shadow-release:
     - job: pkg-hash
       artifacts: true
   rules:
-    - if: $CI_COMMIT_BRANCH != 'master' && $CI_COMMIT_TAG
+    - if: $CI_COMMIT_TAG && $CI_COMMIT_TAG !~ /^v/
   artifacts:
     paths:
       - linux/pamhyr-gnulinux.tar.xz
@@ -672,7 +672,7 @@ tag-release:
     - job: pkg-hash
       artifacts: true
   rules:
-    - if: $CI_COMMIT_BRANCH == 'master' && $CI_COMMIT_TAG
+    - if: $CI_COMMIT_TAG =~ /^v/
   artifacts:
     paths:
       - linux/pamhyr-gnulinux.tar.xz

AUTHORS

@@ -1,4 +1,4 @@
 Sylvain COULIBALY, INRAE, 2020 - 2022
 Théophile TERRAZ, INRAE, 2022 - 2024
-Pierre-Antoine ROUBY, INRAE, 2023 - 2025
+Pierre-Antoine ROUBY, INRAE, 2023 - 2026
 Dylan JEANNIN, INRAE, 2026

src/Checker/Checker.py

@@ -1,5 +1,5 @@
 # Checker.py -- Pamhyr abstract checker class
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Checker/Mage.py

@@ -1,5 +1,5 @@
 # Mage.py -- Pamhyr MAGE checkers
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -229,7 +229,11 @@ for each reach"
         gls = []
 
         for edge in edges:
-            comp, incomp = edge.reach.compute_guidelines()
+            profiles = edge.reach.enabled_profiles
+            comp, incomp = edge.reach.compute_guidelines(
+                profiles=profiles,
+                update_cache=False
+            )
             if len(incomp) != 0:
                 self._status = STATUS.WARNING
                 self._summary = "incomplete_guideline"
@@ -237,7 +241,6 @@ for each reach"
 
             gls.append(comp)
 
-            profiles = edge.reach.profiles
             for profile in profiles:
                 if not profile.has_standard_named_points():
                     self._status = STATUS.WARNING

src/Checker/Study.py

@@ -1,5 +1,5 @@
 # Study.py -- Pamhyr study checkers
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -87,7 +87,7 @@ class StudyGeometryChecker(AbstractModelChecker):
             return False
 
         for edge in edges:
-            if len(edge.reach.profiles) < 2:
+            if len(edge.reach.enabled_profiles) < 2:
                 summary = "no_geometry_defined"
                 status = STATUS.ERROR
                 ok = False
@@ -132,8 +132,12 @@ class StudyInitialConditionsChecker(AbstractModelChecker):
             return ok
 
         ic = river.initial_conditions[reach]
-        len_ic = len(ic)
+        enabled_profiles = set(reach.enabled_profiles)
-        len_reach = len(reach)
+        len_ic = sum(
+            data["section"] in enabled_profiles
+            for data in ic.data
+        )
+        len_reach = len(enabled_profiles)
 
         if len_ic < len_reach:
             self._summary = "initial_condition_missing_profile"

src/Meshing/AMeshingTool.py

@@ -1,5 +1,5 @@
 # AMeshingTool.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Meshing/Internal.py

@@ -1,5 +1,5 @@
 # Internal.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -57,6 +57,13 @@ class InternalMeshing(AMeshingTool):
 
         # we never modify original profiles, we work on the copies
         m_profiles = self.st_to_m(profiles, guide_list)
+
+        # Adapt the spacing to the kilometre-point direction. The value from
+        # the dialog is a distance, so only its magnitude is significant.
+        step = self.signed_step(
+            step, m_profiles[0].rk, m_profiles[-1].rk
+        )
+
         new_profiles = self.interpolate_transversal_step(m_profiles, step)
 
         for new_profiles2 in new_profiles:
@@ -65,6 +72,12 @@ class InternalMeshing(AMeshingTool):
 
         return new_profiles
 
+    @staticmethod
+    def signed_step(step, begin_rk, end_rk):
+        if end_rk < begin_rk:
+            return -abs(step)
+        return abs(step)
+
     def st_to_m(self, profiles, guide_list):
         guide_list = ["un"] + guide_list + ["np"]
         max_values = [0] * (len(guide_list) - 1)
@@ -124,10 +137,11 @@ class InternalMeshing(AMeshingTool):
                     p.points[k].z = pt1[k].z + \
                         dj*(pt2[k].z -
                             pt1[k].z)
-                    p.rk = profiles[i].rk + \
+                    p.rk = round(profiles[i].rk +
-                        dj*(profiles[i+1].rk -
+                                 dj*(profiles[i+1].rk -
-                            profiles[i].rk)
+                                 profiles[i].rk), 2)
                     p.name = f'interpol{p.rk}'
+                p.interpolated = True
                 new_profiles2.append(p)
             new_profiles.append(new_profiles2)
 
@@ -158,15 +172,14 @@ class InternalMeshing(AMeshingTool):
 
         ltot1 = 0.0
         ltot2 = 0.0
-        alpha = []
+        alpha = [0.0]
-        beta = []
+        beta = [0.0]
         # remove names
         sect2.points[start2].name = ''
         sect2.points[end2].name = ''
         for i in range(len1):
             ltot1 += sect1.point(start1+i).dist(sect1.point(start1+i+1))
             alpha.append(ltot1)
-        alpha = list(map(lambda x: x/ltot1, alpha))  # target ratios
         for i in range(len2):
             ltot2 += sect2.point(start2+i).dist(sect2.point(start2+i+1))
             beta.append(ltot2)
@@ -181,68 +194,40 @@ class InternalMeshing(AMeshingTool):
             sect2.add_npoints(len1-len2)
             len2 = len1
         else:  # regular case
+            alpha = list(map(lambda x: x/ltot1, alpha))  # target ratios
             beta = list(map(lambda x: x/ltot2, beta))  # current ratios
-            for i in range(len1 - len2):
+            match = self._match_indices(alpha, beta)
-                beta.append(1.0)
-            beta.append(0.0)  # beta[-1]
-            # loop on the points to insert
-            for k in range(len1-len2):
-                trouve = False
-                for j0 in range(len2):
-                    if trouve:
-                        break
-                    undeplus = True
-                    for j1 in range(j0, len2):
-                        if undeplus:
-                            if beta[j1] <= alpha[j1]:
-                                undeplus = False
-                                break
-                    if undeplus:
-                        if j0 == len2:
-                            trouve = True
-                        else:
-                            j1 = j0+1
-                            if beta[j0]-alpha[j0] > alpha[j1]-beta[j0]:
-                                trouve = True
 
-                    if trouve:
+            insertions_per_segment = []  # liste de (index, [points])
-                        len2 += 1
+            for j in range(len2):
-                        for i in reversed(range(j0, len2)):
+                i_start = match[j]
-                            beta[i+1] = beta[i]
+                i_end = match[j + 1]
-                        if (beta[j0] == beta[j0-1]):
+                q_start = sect2.point(start2 + j)
-                            # rien
+                q_end = sect2.point(start2 + j + 1)
-                            pass
+
-                        else:
+                new_points = []
-                            ratio = (alpha[j0] - beta[j0-1]) \
+                if i_end - i_start > 1:
-                                    / (beta[j0] - beta[j0-1])
+                    u_start, u_end = alpha[i_start], alpha[i_end]
-                            if ratio < 0.0:
+                    span = u_end - u_start
-                                logger.warning(f"ratio négatif {ratio}")
+                    for k in range(i_start + 1, i_end):
-                                # on double le point a gauche
+                        ratio = (alpha[k] - u_start) / span  # dans [0,1]
-                                p = sect2.point(start2+j0-1).copy()
+                        p = q_start.copy()
-                                sect2.insert_point(start2+j0-1, p)
+                        p.name = ''
-                                sect2.point(start2+j0-1).name = ''
+                        p.x = (1.0-ratio) * q_start.x + ratio * q_end.x
-                                beta[j0] = beta[j0-1]
+                        p.y = (1.0-ratio) * q_start.y + ratio * q_end.y
-                            else:
+                        p.z = (1.0-ratio) * q_start.z + ratio * q_end.z
-                                p = sect2.point(start2+j0).copy()
+                        new_points.append(p)
-                                sect2.insert_point(start2+j0, p)
+
-                                sect2.point(start2+j0+1).name = ''
+                # à insérer après l'indice j
-                                sect2.point(start2+j0+1).x = \
+                insertions_per_segment.append((j, new_points))
-                                    (1.0-ratio) * sect2.point(start2+j0).x + \
+
-                                    ratio * sect2.point(start2+j0+2).x
+            # Insertion en ordre décroissant de j
-                                sect2.point(start2+j0+1).y = \
+            # pour ne pas perturber les indices
-                                    (1.0-ratio) * sect2.point(start2+j0).y + \
+            for j, new_points in reversed(insertions_per_segment):
-                                    ratio * sect2.point(start2+j0+2).y
+                for offset, p in enumerate(new_points):
-                                sect2.point(start2+j0+1).z = \
+                    sect2.insert_point(start2 + j + 1 + offset, p)
-                                    (1.0-ratio) * sect2.point(start2+j0).z + \
+                    len2 += 1
-                                    ratio * sect2.point(start2+j0+2).z
-                                beta[j0] = (1.-ratio)*beta[j0-1] \
-                                    + ratio*beta[j0+1]
 
-        if len1 > len2:
-            for i in range(len1 - len2):
-                p = sect2.point(start2+len2).copy()
-                sect2.insert_point(start2+len2, p)
-                sect2.point(start2+len2).name = ''
         if tag1 != "un":
             sect2.point(start2).name = tag1
         if tag2 != "np":
@@ -250,6 +235,71 @@ class InternalMeshing(AMeshingTool):
 
         sect2.modified()
 
+    def _match_indices(self, u_ref, v_target):
+        # appariement optimal (ordre croissant) par programmation dynamique
+        """
+        Trouve, pour chaque v_target[j], un indice i_j dans u_ref tel que
+        i_0 < i_1 < ... < i_{m-1} et
+        Sum |u_ref[i_j] - v_target[j]| soit minimal.
+
+        Retourne la liste des indices i_j (longueur m),
+        avec i_0 = 0 et i_{m-1} = n-1 imposés
+        (les extrémités se correspondent forcément).
+
+        """
+        n = len(u_ref)
+        m = len(v_target)
+
+        # Les extrémités sont fixées.
+        fixed_first, fixed_last = 0, n - 1
+
+        # DP sur les indices disponibles entre fixed_first+1 et fixed_last-1
+        # dp[j][i] = coût minimal pour apparier v_target[1..j] aux indices
+        # se terminant à l'indice i (i croissant strict), j de 1 à m-2.
+        if m == 2:
+            return [fixed_first, fixed_last]
+
+        # indices internes possibles
+        candidates = list(range(fixed_first + 1, fixed_last))
+        inner_targets = v_target[1:-1]  # cibles internes (j = 1..m-2)
+
+        INF = float("inf")
+        # dp[j] : dict indice_candidat -> (coût_min, provenance)
+        dp = [{} for _ in range(len(inner_targets))]
+
+        for j, vt in enumerate(inner_targets):
+            for idx_pos, i in enumerate(candidates):
+                cost_here = abs(u_ref[i] - vt)
+                if j == 0:
+                    # doit être > fixed_first
+                    dp[j][i] = (cost_here, fixed_first)
+                else:
+                    best = (INF, None)
+                    for i_prev in candidates[:idx_pos]:
+                        if i_prev in dp[j - 1]:
+                            c = dp[j - 1][i_prev][0] + cost_here
+                            if c < best[0]:
+                                best = (c, i_prev)
+                    if best[1] is not None:
+                        dp[j][i] = best
+
+        # Reconstruction : on part du dernier niveau, on choisit le
+        # meilleur indice tel que la suite jusqu'à fixed_last
+        # reste croissante et valide.
+        last_level = dp[-1]
+        valid = {i: c for i, c in last_level.items() if i < fixed_last}
+        if not valid:
+            raise RuntimeError("Alignement impossible avec ces données.")
+        best_i = min(valid, key=lambda i: valid[i][0])
+
+        chain = [best_i]
+        for j in range(len(inner_targets) - 1, 0, -1):
+            prev_i = dp[j][chain[-1]][1]
+            chain.append(prev_i)
+        chain.reverse()
+
+        return [fixed_first] + chain + [fixed_last]
+
     def update_rk(self, reach, begin_rk, end_rk,
                   step: float = 50,
                   limites=[-1, -1],

src/Meshing/Mage.py

@@ -1,5 +1,5 @@
 # Mage.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Meshing/__init__.py

@@ -1,5 +1,5 @@
 # __init__.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Meshing/test_Meshing.py

@@ -1,5 +1,5 @@
 # test_Model.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/BoundaryCondition/BoundaryCondition.py

@@ -1,5 +1,5 @@
 # BoundaryCondition.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -514,42 +514,6 @@ class BoundaryCondition(SQLSubModel):
         self._sigma = float(value)
         self.modified()
 
-    @property
-    def d50(self):
-        return self._d50
-
-    @d50.setter
-    def d50(self, value):
-        self._d50 = float(value)
-        self.modified()
-
-    @property
-    def sigma(self):
-        return self._sigma
-
-    @sigma.setter
-    def sigma(self, value):
-        self._sigma = float(value)
-        self.modified()
-
-    @property
-    def d50(self):
-        return self._d50
-
-    @d50.setter
-    def d50(self, value):
-        self._d50 = float(value)
-        self.modified()
-
-    @property
-    def sigma(self):
-        return self._sigma
-
-    @sigma.setter
-    def sigma(self, value):
-        self._sigma = float(value)
-        self.modified()
-
     @property
     def header(self):
         return self._header.copy()

src/Model/BoundaryCondition/BoundaryConditionList.py

@@ -1,5 +1,5 @@
 # BoundaryConditionList.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/BoundaryCondition/BoundaryConditionTypes.py

@@ -1,5 +1,5 @@
 # BoundaryConditionTypes.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/BoundaryConditionsAdisTS/BoundaryConditionAdisTS.py

@@ -1,5 +1,5 @@
 # BoundaryConditionsAdisTS.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -531,7 +531,7 @@ class BoundaryConditionAdisTS(SQLSubModel):
             new_0 = self._types[0](data[0].replace(",", "."))
             new_1 = self._types[1](data[1].replace(",", "."))
 
-        return (new_0, new_1)
+        return Data(new_0, new_1, types=self._types, status=self._status)
 
     def add(self, index: int):
         value = Data(
@@ -543,7 +543,10 @@ class BoundaryConditionAdisTS(SQLSubModel):
         return value
 
     def insert(self, index: int, value):
-        self._data.insert(index, value)
+        if value in self._data:
+            value.set_as_not_deleted()
+        else:
+            self._data.insert(index, value)
         self.modified()
 
     def delete_i(self, indexes):

src/Model/BoundaryConditionsAdisTS/BoundaryConditionsAdisTSList.py

@@ -1,5 +1,5 @@
 # BoundaryConditionsAdisTSList.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/BoundaryConditionsTemperature/BoundaryConditionTemperature.py

@@ -0,0 +1,481 @@
+# BoundaryConditionsTemperature.py -- Pamhyr
+# Copyright (C) 2023-2025  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import logging
+
+from tools import (
+    trace, timer,
+    old_pamhyr_date_to_timestamp,
+    date_iso_to_timestamp,
+    date_dmy_to_timestamp,
+)
+
+from Model.Tools.PamhyrDB import SQLSubModel
+from Model.Except import NotImplementedMethodeError
+from Model.Scenario import Scenario
+
+logger = logging.getLogger()
+
+
+class Data(SQLSubModel):
+    _sub_classes = []
+
+    def __init__(self,
+                 data0, data1,
+                 id: int = -1,
+                 types=[float, float],
+                 status=None,
+                 owner_scenario=-1):
+        super(Data, self).__init__(
+            id=id, status=status,
+            owner_scenario=owner_scenario
+        )
+
+        self._types = types
+        self._data = [data0, data1]
+
+    @classmethod
+    def _db_create(cls, execute, ext=""):
+        execute(f"""
+          CREATE TABLE boundary_condition_data_temperature{ext}(
+            {cls.create_db_add_pamhyr_id()},
+            deleted BOOLEAN NOT NULL DEFAULT FALSE,
+            data0 TEXT NOT NULL,
+            data1 TEXT NOT NULL,
+            bca INTEGER,
+            {Scenario.create_db_add_scenario()},
+            {Scenario.create_db_add_scenario_fk()},
+            FOREIGN KEY(bca)
+                REFERENCES boundary_condition_temperature(pamhyr_id)
+          )
+        """)
+
+        return True
+
+    @classmethod
+    def _db_update(cls, execute, version, data=None):
+        major, minor, release = version.strip().split(".")
+        created = False
+        if major == "0" and minor == "0":
+            if int(release) < 11:
+                cls._db_create(execute)
+                created = True
+
+        if major == "0" and (int(minor) < 2 or
+                             (int(minor) == 2 and int(release) <= 7)):
+            if not cls.is_table_exists(execute,
+                                       "boundary_condition_data_temperature"):
+                cls._db_create(execute)
+                created = True
+
+        if not created:
+            return cls._update_submodel(execute, version, data)
+
+        return True
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = []
+        status = data['status']
+        scenario = data["scenario"]
+        loaded = data['loaded_pid']
+
+        if scenario is None:
+            return new
+
+        bca = data["bca"]
+
+        table = execute(
+            "SELECT pamhyr_id, deleted, data0, data1, scenario FROM " +
+            "boundary_condition_data_temperature " +
+            f"WHERE scenario = {scenario.id} " +
+            # f"AND pamhyr_id NOT IN ({', '.join(map(str, loaded))}) " +
+            f"AND bca = {bca.id}"
+        )
+
+        if table is not None:
+            for row in table:
+                it = iter(row)
+
+                pid = next(it)
+                deleted = (next(it) == 1)
+                data0 = next(it)
+                data1 = next(it)
+                owner_scenario = next(it)
+
+                bc = cls(
+                    data0, data1,
+                    id=pid,
+                    status=status,
+                    owner_scenario=owner_scenario
+                )
+                if deleted:
+                    bc.set_as_deleted()
+
+                loaded.add(pid)
+                new.append(bc)
+
+        data["scenario"] = scenario.parent
+        new += cls._db_load(execute, data)
+        data["scenario"] = scenario
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        if not self.must_be_saved():
+            return True
+
+        bca = data["bca"]
+
+        data0 = self._db_format(self._data[0])
+        data1 = self._db_format(self._data[1])
+
+        execute(
+            "INSERT INTO " +
+            "boundary_condition_data_temperature(" +
+            "pamhyr_id, deleted, data0, data1, bca, scenario) " +
+            f"VALUES ({self.id}, {self._db_format(self.is_deleted())}, " +
+            f"'{data0}', {data1}, {bca.id}, " +
+            f"{self._status.scenario_id})"
+        )
+
+        return True
+
+    def __getitem__(self, key):
+        return self._types[key](self._data[key])
+
+    def __setitem__(self, key, value):
+        self._data[key] = self._types[key](value)
+
+
+class BoundaryConditionTemperature(SQLSubModel):
+    _sub_classes = [Data]
+
+    def __init__(self, id: int = -1, status=None, owner_scenario=-1):
+        super(BoundaryConditionTemperature, self).__init__(
+            id=id, status=status,
+            owner_scenario=owner_scenario
+        )
+
+        self._status = status
+
+        self._name = ""
+        self._node = None
+        self._data = []
+        self._header = []
+        self._types = [self.time_convert, float]
+
+    @classmethod
+    def _db_create(cls, execute, ext=""):
+        execute(f"""
+          CREATE TABLE boundary_condition_temperature{ext}(
+            {cls.create_db_add_pamhyr_id()},
+            deleted BOOLEAN NOT NULL DEFAULT FALSE,
+            name TEXT NOT NULL,
+            node INTEGER,
+            {Scenario.create_db_add_scenario()},
+            {Scenario.create_db_add_scenario_fk()},
+            FOREIGN KEY(node) REFERENCES river_node(pamhyr_id)
+          )
+        """)
+
+        if ext != "":
+            return True
+
+        return cls._create_submodel(execute)
+
+    @classmethod
+    def _db_update(cls, execute, version, data=None):
+        major, minor, release = version.strip().split(".")
+        created = False
+
+        if major == "0" and (int(minor) < 2 or (
+         int(minor) == 2 and int(release) <= 7)):
+            if not cls.is_table_exists(execute,
+                                       "boundary_condition_temperature"):
+                cls._db_create(execute)
+                created = True
+
+        if not created:
+            return cls._update_submodel(execute, version, data)
+
+        return True
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = []
+        status = data['status']
+        nodes = data['nodes']
+        scenario = data["scenario"]
+        loaded = data['loaded_pid']
+
+        if scenario is None:
+            return new
+
+        sql = (
+            "SELECT pamhyr_id, deleted, name, node, scenario "
+            "FROM boundary_condition_temperature " +
+            f"WHERE scenario = {scenario.id} "
+        )
+
+        table = execute(sql)
+
+        if table is not None:
+            for row in table:
+                it = iter(row)
+
+                pid = next(it)
+                deleted = (next(it) == 1)
+                bc_name = next(it)
+                node = next(it)
+                owner_scenario = next(it)
+
+                bc = cls(
+                    id=pid,
+                    status=status,
+                    owner_scenario=owner_scenario
+                )
+                if deleted:
+                    bc.set_as_deleted()
+
+                bc.name = bc_name
+
+                bc.node = None
+                if node != -1:
+                    tmp = next(
+                        filter(
+                            lambda n: n.id == node, nodes
+                        ),
+                        None
+                    )
+                    if tmp is not None:
+                        bc.node = tmp.id
+                    else:
+                        bc.node = -1
+
+                data["bca"] = bc
+                bc._data = Data._db_load(execute, data=data)
+
+                loaded.add(pid)
+                new.append(bc)
+
+        data["scenario"] = scenario.parent
+        new += cls._db_load(execute, data)
+        data["scenario"] = scenario
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        if not self.must_be_saved():
+            return True
+
+        execute(
+            "DELETE FROM boundary_condition_temperature " +
+            f"WHERE pamhyr_id = {self.id} " +
+            f"AND scenario = {self._status.scenario_id} "
+        )
+        execute(
+            "DELETE FROM boundary_condition_data_temperature " +
+            f"WHERE bca = {self.id} " +
+            f"AND scenario = {self._status.scenario_id} "
+        )
+
+        node = -1
+        if self._node is not None:
+            node = self._node
+
+        execute(
+            "INSERT INTO " +
+            "boundary_condition_temperature(" +
+            "pamhyr_id, deleted, name, " +
+            "node, scenario) " +
+            "VALUES (" +
+            f"{self.id}, {self._db_format(self.is_deleted())}, " +
+            f"'{self._db_format(self._name)}', {node}, " +
+            f"{self._status.scenario_id}" +
+            ")"
+        )
+
+        data["bca"] = self
+
+        ind = 0
+        for d in self._data:
+            data["ind"] = ind
+
+            d._db_save(execute, data)
+
+            ind += 1
+
+        return True
+
+    def _data_traversal(self,
+                        predicate=lambda obj, data: True,
+                        modifier=lambda obj, data: None,
+                        data={}):
+        if predicate(self, data):
+            modifier(self, data)
+
+        for d in self._data:
+            d._data_traversal(predicate, modifier, data)
+
+    def __len__(self):
+        return len(
+            list(
+                filter(
+                    lambda el: el is not None and not el.is_deleted(),
+                    self._data
+                )
+            )
+        )
+
+    @classmethod
+    def time_convert(cls, data):
+        if type(data) is str:
+            if data.count("-") == 2:
+                return date_iso_to_timestamp(data)
+            if data.count("/") == 2:
+                return date_dmy_to_timestamp(data)
+            if data.count(":") == 3:
+                return old_pamhyr_date_to_timestamp(data)
+            if data.count(":") == 2:
+                return old_pamhyr_date_to_timestamp("00:" + data)
+            if data.count(".") == 1:
+                return round(float(data))
+
+        return int(data)
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, name):
+        self._name = name
+        self.modified()
+
+    @property
+    def node(self):
+        return self._node
+
+    @node.setter
+    def node(self, node):
+        self._node = node
+        self.modified()
+
+    @property
+    def header(self):
+        return self._header.copy()
+
+    @header.setter
+    def header(self, header):
+        self._header = header
+        self.modified()
+
+    @property
+    def data(self):
+        return list(
+            filter(
+                lambda el: el is not None and not el.is_deleted(),
+                self._data
+            )
+        )
+
+    @property
+    def _default_0(self):
+        return self._types[0](0)
+
+    @property
+    def _default_1(self):
+        return self._types[1](0.0)
+
+    def new_from_data(self, header, data):
+        new_0 = self._default_0
+        new_1 = self._default_1
+
+        if len(header) != 0:
+            for i in [0, 1]:
+                for j in range(len(header)):
+                    if self._header[i] == header[j]:
+                        if i == 0:
+                            new_0 = self._types[i](data[j].replace(",", "."))
+                        else:
+                            new_1 = self._types[i](data[j].replace(",", "."))
+        else:
+            new_0 = self._types[0](data[0].replace(",", "."))
+            new_1 = self._types[1](data[1].replace(",", "."))
+
+        return Data(new_0, new_1, types=self._types, status=self._status)
+
+    def add(self, index: int):
+        value = Data(
+            self._default_0, self._default_1,
+            status=self._status
+        )
+        self._data.insert(index, value)
+        self.modified()
+        return value
+
+    def insert(self, index: int, value):
+        if value in self._data:
+            value.set_as_not_deleted()
+        else:
+            self._data.insert(index, value)
+        self.modified()
+
+    def delete_i(self, indexes):
+        list(
+            map(
+                lambda e: e[1].set_as_deleted(),
+                filter(
+                    lambda e: e[0] in indexes,
+                    enumerate(self.data)
+                )
+            )
+        )
+        self.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.modified()
+
+    def index(self, bc):
+        self._data.index(bc)
+
+    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 = self._data[index]
+        v[column] = self._types[column](value)
+        self._data[index] = v
+        self.modified()
+
+    def set_i_0(self, index: int, value):
+        self._set_i_c_v(index, 0, value)
+
+    def set_i_1(self, index: int, value):
+        self._set_i_c_v(index, 1, value)

src/Model/BoundaryConditionsTemperature/BoundaryConditionsTemperatureList.py

@@ -1,5 +1,5 @@
-# OutputRKListAdists.py -- Pamhyr
+# BoundaryConditionsTemperatureList.py -- Pamhyr
-# Copyright (C) 2024-2025  INRAE
+# Copyright (C) 2023-2025  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
@@ -16,44 +16,56 @@
 
 # -*- coding: utf-8 -*-
 
+from copy import copy
 from tools import trace, timer
 
-from Model.Except import NotImplementedMethodeError
 from Model.Tools.PamhyrListExt import PamhyrModelList
-from Model.OutputRKAdists.OutputRKAdists import OutputRKAdists
+from Model.Except import NotImplementedMethodeError
+
+from Model.BoundaryConditionsTemperature.BoundaryConditionTemperature \
+    import BoundaryConditionTemperature
 
 
-class OutputRKAdistsList(PamhyrModelList):
+class BoundaryConditionsTemperatureList(PamhyrModelList):
-    _sub_classes = [OutputRKAdists]
+    _sub_classes = [
+        BoundaryConditionTemperature,
+    ]
 
     @classmethod
     def _db_load(cls, execute, data=None):
-        new = cls(status=data["status"])
+        new = cls(status=data['status'])
 
-        new._lst = OutputRKAdists._db_load(execute, data)
+        if data is None:
+            data = {}
+
+        new._lst = BoundaryConditionTemperature._db_load(execute, data)
 
         return new
 
     def _db_save(self, execute, data=None):
-        ok = True
-
-        # Delete previous data
         execute(
-            "DELETE FROM output_rk_adists " +
+            "DELETE FROM boundary_condition_temperature " +
+            f"WHERE scenario = {self._status.scenario_id}"
+        )
+        execute(
+            "DELETE FROM boundary_condition_data_temperature " +
             f"WHERE scenario = {self._status.scenario_id}"
         )
 
-        for sl in self._lst:
+        if data is None:
-            ok &= sl._db_save(execute, data)
+            data = {}
 
-        return ok
+        for bca in self._lst:
+            bca._db_save(execute, data=data)
 
-    @property
+        return True
-    def OutputRK_List(self):
-        return self.lst
 
-    def new(self, lst, index):
+    def new(self, index):
-        n = OutputRKAdists(status=self._status)
+        n = BoundaryConditionTemperature(status=self._status)
         self._lst.insert(index, n)
         self._status.modified()
         return n
+
+    @property
+    def BCs_Temperature_List(self):
+        return self.lst

src/Model/D90AdisTS/D90AdisTS.py

@@ -1,5 +1,5 @@
 # D90AdisTS.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -275,3 +275,44 @@ class D90AdisTS(SQLSubModel):
             x.set_as_not_deleted()
 
         self.modified()
+
+    def split_reach(self, reach, profile, reach1, reach2):
+        split_rk = profile.rk
+        reach_rks = reach.reach.get_rk()
+        if len(reach_rks) == 0:
+            return
+
+        parts = [
+            (reach1.id, min(reach_rks), split_rk),
+            (reach2.id, split_rk, max(reach_rks)),
+        ]
+        specifications = [
+            specification
+            for specification in self._data
+            if (not specification.is_deleted() and
+                specification.reach == reach.id)
+        ]
+
+        for specification in specifications:
+            begin = specification.start_rk
+            end = specification.end_rk
+            if begin is None or end is None:
+                continue
+
+            lower, upper = sorted((begin, end))
+            reverse = begin > end
+
+            for new_reach, part_lower, part_upper in parts:
+                clipped_lower = max(lower, part_lower)
+                clipped_upper = min(upper, part_upper)
+                if clipped_lower >= clipped_upper:
+                    continue
+
+                start_rk = clipped_upper if reverse else clipped_lower
+                end_rk = clipped_lower if reverse else clipped_upper
+                self._data.append(specification.cloned_for(
+                    new_reach, start_rk, end_rk
+                ))
+
+        if len(specifications) != 0:
+            self.modified()

src/Model/D90AdisTS/D90AdisTSList.py

@@ -1,5 +1,5 @@
 # D90AdisTSList.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -61,6 +61,10 @@ class D90AdisTSList(PamhyrModelList):
         self._status.modified()
         return n
 
+    def split_reach(self, reach, profile, reach1, reach2):
+        for d90 in self.lst:
+            d90.split_reach(reach, profile, reach1, reach2)
+
     @property
     def D90_AdisTS_List(self):
         return self.lst

src/Model/D90AdisTS/D90AdisTSSpec.py

@@ -1,5 +1,5 @@
 # D90AdisTSSpec.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -261,3 +261,13 @@ class D90AdisTSSpec(SQLSubModel):
     def enabled(self, enabled):
         self._enabled = enabled
         self.modified()
+
+    def cloned_for(self, reach, start_rk, end_rk):
+        new = D90AdisTSSpec(name=self._name_section, status=self._status)
+        new._reach = reach
+        new._start_rk = start_rk
+        new._end_rk = end_rk
+        new._d90 = self._d90
+        new._enabled = self._enabled
+        new.modified()
+        return new

src/Model/DIFAdisTS/DIFAdisTS.py

@@ -1,5 +1,5 @@
 # DIFAdisTS.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -329,3 +329,44 @@ class DIFAdisTS(SQLSubModel):
             x.set_as_not_deleted()
 
         self.modified()
+
+    def split_reach(self, reach, profile, reach1, reach2):
+        split_rk = profile.rk
+        reach_rks = reach.reach.get_rk()
+        if len(reach_rks) == 0:
+            return
+
+        parts = [
+            (reach1.id, min(reach_rks), split_rk),
+            (reach2.id, split_rk, max(reach_rks)),
+        ]
+        specifications = [
+            specification
+            for specification in self._data
+            if (not specification.is_deleted() and
+                specification.reach == reach.id)
+        ]
+
+        for specification in specifications:
+            begin = specification.start_rk
+            end = specification.end_rk
+            if begin is None or end is None:
+                continue
+
+            lower, upper = sorted((begin, end))
+            reverse = begin > end
+
+            for new_reach, part_lower, part_upper in parts:
+                clipped_lower = max(lower, part_lower)
+                clipped_upper = min(upper, part_upper)
+                if clipped_lower >= clipped_upper:
+                    continue
+
+                start_rk = clipped_upper if reverse else clipped_lower
+                end_rk = clipped_lower if reverse else clipped_upper
+                self._data.append(specification.cloned_for(
+                    new_reach, start_rk, end_rk
+                ))
+
+        if len(specifications) != 0:
+            self.modified()

src/Model/DIFAdisTS/DIFAdisTSList.py

@@ -1,5 +1,5 @@
 # DIFAdisTSList.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -61,6 +61,10 @@ class DIFAdisTSList(PamhyrModelList):
         self._status.modified()
         return n
 
+    def split_reach(self, reach, profile, reach1, reach2):
+        for dif in self.lst:
+            dif.split_reach(reach, profile, reach1, reach2)
+
     @property
     def DIF_AdisTS_List(self):
         return self.lst

src/Model/DIFAdisTS/DIFAdisTSSpec.py

@@ -1,5 +1,5 @@
 # DIFAdisTSSpec.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -293,3 +293,15 @@ class DIFAdisTSSpec(SQLSubModel):
     def enabled(self, enabled):
         self._enabled = enabled
         self._status.modified()
+
+    def cloned_for(self, reach, start_rk, end_rk):
+        new = DIFAdisTSSpec(method=self._method, status=self._status)
+        new._reach = reach
+        new._start_rk = start_rk
+        new._end_rk = end_rk
+        new._dif = self._dif
+        new._b = self._b
+        new._c = self._c
+        new._enabled = self._enabled
+        new.modified()
+        return new

src/Model/Except.py

@@ -1,5 +1,5 @@
 # Except.py -- Pamhyr model exceptions
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/Friction/Friction.py

@@ -1,5 +1,5 @@
 # Friction.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/Friction/FrictionList.py

@@ -1,5 +1,5 @@
 # FrictionList.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -109,16 +109,22 @@ class FrictionList(PamhyrModelList):
             ((999 ** 100), -(999 ** 100))
         )
 
-        frictions = list(
+        for friction in self.lst:
-            filter(
+            lower, upper = sorted((friction.begin_rk, friction.end_rk))
-                lambda f: ((rk_min <= f.begin_rk <= rk_max) or
+            clipped_lower = max(lower, rk_min)
-                           (rk_min <= f.end_rk <= rk_max)),
+            clipped_upper = min(upper, rk_max)
-                self._lst))
+            if clipped_lower >= clipped_upper:
+                continue
 
-        for ind, friction in enumerate(frictions):
             n = friction.cloned_for(reach)
+            if friction.begin_rk > friction.end_rk:
+                n.begin_rk = clipped_upper
+                n.end_rk = clipped_lower
+            else:
+                n.begin_rk = clipped_lower
+                n.end_rk = clipped_upper
 
-            new._lst.insert(ind, n)
+            new._lst.append(n)
             new._status.modified()
 
         return new

src/Model/Geometry/Point.py

@@ -1,5 +1,5 @@
 # Point.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -55,8 +55,11 @@ class Point(SQLSubModel):
 
     @name.setter
     def name(self, name):
+        changed = self._name != name
         self._name = name
         self.modified()
+        if changed and self._profile is not None:
+            self._profile.content_modified()
 
     def is_named(self):
         """

src/Model/Geometry/PointXY.py

@@ -1,5 +1,5 @@
 # PointXY.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/Geometry/PointXYZ.py

@@ -1,5 +1,5 @@
 # PointXYZ.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -95,12 +95,11 @@ class PointXYZ(Point):
                     "ADD COLUMN deleted BOOLEAN NOT NULL DEFAULT FALSE"
                 )
 
-        if major == "0" and minor == "2":
+        # Try to create index at each update
-            if int(release) < 5:
+        execute(
-                execute(
+            "CREATE INDEX IF NOT EXISTS idx_point " +
-                    "CREATE INDEX idx_point " +
+            "ON geometry_pointXYZ(profile, scenario);"
-                    "ON geometry_pointXYZ(profile, scenario);"
+        )
-                )
 
         return cls._update_submodel(execute, version, data)
 
@@ -329,8 +328,11 @@ class PointXYZ(Point):
 
     @x.setter
     def x(self, value):
+        changed = self._x != float(value)
         self._x = float(value)
         self.modified()
+        if changed and self._profile is not None:
+            self._profile.content_modified()
 
     @property
     def y(self):
@@ -338,8 +340,11 @@ class PointXYZ(Point):
 
     @y.setter
     def y(self, value):
+        changed = self._y != float(value)
         self._y = float(value)
         self.modified()
+        if changed and self._profile is not None:
+            self._profile.content_modified()
 
     @property
     def z(self):
@@ -347,8 +352,11 @@ class PointXYZ(Point):
 
     @z.setter
     def z(self, value):
+        changed = self._z != float(value)
         self._z = float(value)
         self.modified()
+        if changed and self._profile is not None:
+            self._profile.content_modified()
 
     def shift(self, x, y, z):
         self.x += x

src/Model/Geometry/Profile.py

@@ -1,5 +1,5 @@
 # Profile.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -47,6 +47,8 @@ class Profile(object):
         self._sl = None
 
         self._points: List[Point] = []
+        self._modification_count = 0
+        self._old_interpolated = ""
 
         self._profile_type = _type
 
@@ -160,8 +162,13 @@ class Profile(object):
 
     @rk.setter
     def rk(self, value: float):
-        self._rk = float(value)
+        value = float(value)
-        self.modified()
+        changed = value != self._rk
+        self._rk = value
+        if changed:
+            self.content_modified()
+        else:
+            self.modified()
 
     @property
     def name(self):
@@ -173,8 +180,13 @@ class Profile(object):
 
     @name.setter
     def name(self, value: str):
-        self._name = value.strip()
+        value = value.strip()
-        self.modified()
+        changed = value != self._name
+        self._name = value
+        if changed:
+            self.content_modified()
+        else:
+            self.modified()
 
     @property
     def sl(self):
@@ -217,6 +229,38 @@ class Profile(object):
         return [point for point in self.points
                 if point.is_named()]
 
+    @property
+    def modification_count(self):
+        """Content revision for this session; not stored in the database."""
+        return self._modification_count
+
+    def increase_modification_count(self):
+        """Increase content revision for this session;
+        not stored in the database."""
+        self._modification_count += 1
+
+    def decrease_modification_count(self):
+        """Decrease content revision for this session;
+        not stored in the database."""
+        self._modification_count -= 1
+
+    @property
+    def old_interpolated(self):
+        """Old interpolated value for this session;
+        not stored in the database."""
+        return self._old_interpolated
+
+    @old_interpolated.setter
+    def old_interpolated(self, value):
+        self._old_interpolated = value
+
+    def content_modified(self):
+        """An edited profile is no longer an interpolation result."""
+        # self._modification_count += 1
+        if hasattr(self, "_interpolated"):
+            self._interpolated = False
+        self.modified()
+
     def insert_point(self, index: int, point: Point):
         """Insert point at index.
 
@@ -232,7 +276,7 @@ class Profile(object):
         else:
             self._points.insert(index, point)
 
-        self.modified()
+        self.content_modified()
 
     def delete_i(self, indexes: list):
         list(
@@ -245,7 +289,7 @@ class Profile(object):
             )
         )
 
-        self.modified()
+        self.content_modified()
 
     def delete_points(self, points):
         """Delete some elements in profile list
@@ -262,7 +306,7 @@ class Profile(object):
                 points
             )
         )
-        self.modified()
+        self.content_modified()
 
     # Move
 
@@ -272,7 +316,7 @@ class Profile(object):
 
             p = self._points
             p[index], p[next] = p[next], p[index]
-            self.modified()
+            self.content_modified()
 
     def move_down_point(self, index: int):
         if index >= 0:
@@ -280,7 +324,7 @@ class Profile(object):
 
             p = self._points
             p[index], p[prev] = p[prev], p[index]
-            self.modified()
+            self.content_modified()
 
     # Sort
 
@@ -297,7 +341,7 @@ class Profile(object):
             key=predicate,
             reverse=is_reversed
         )
-        self.modified()
+        self.content_modified()
 
     @timer
     def sort_with_indexes(self, indexes: list):
@@ -313,12 +357,12 @@ class Profile(object):
                 )
             )
         )
-        self.modified()
+        self.content_modified()
 
     @timer
     def reverse(self):
         self._points.reverse()
-        self.modified()
+        self.content_modified()
 
     # Sediment Layers
 

src/Model/Geometry/ProfileXYZ.py

@@ -1,5 +1,5 @@
 # ProfileXYZ.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -58,7 +58,8 @@ class ProfileXYZ(Profile, SQLSubModel):
                  num=0,
                  nb_point: int = 0,
                  code1: int = 0, code2: int = 0,
-                 status=None, owner_scenario=-1):
+                 status=None, owner_scenario=-1,
+                 enabled=True, interpolated=False):
         """ProfileXYZ constructor
 
         Args:
@@ -90,6 +91,11 @@ class ProfileXYZ(Profile, SQLSubModel):
         self.time_l = 0.0
         self._station = []
         self.station_up_to_date = False
+        self._enabled = bool(enabled)
+        self._interpolated = bool(interpolated)
+
+        self._get_water_limits_cache = {}
+        self._get_water_limits_ac_cache = {}
 
     @classmethod
     def _db_create(cls, execute, ext=""):
@@ -105,6 +111,8 @@ class ProfileXYZ(Profile, SQLSubModel):
             code1 INTEGER NOT NULL,
             code2 INTEGER NOT NULL,
             sl INTEGER,
+            enabled BOOLEAN NOT NULL DEFAULT TRUE,
+            interpolated BOOLEAN NOT NULL DEFAULT FALSE,
             {Scenario.create_db_add_scenario()},
             {Scenario.create_db_add_scenario_fk()},
             FOREIGN KEY(reach) REFERENCES river_reach(pamhyr_id),
@@ -149,6 +157,27 @@ class ProfileXYZ(Profile, SQLSubModel):
                     "ADD COLUMN deleted BOOLEAN NOT NULL DEFAULT FALSE"
                 )
 
+        if major == "0" and int(minor) <= 2:
+            if int(release) < 9:
+                execute(
+                    "ALTER TABLE geometry_profileXYZ " +
+                    "ADD COLUMN enabled BOOLEAN NOT NULL DEFAULT TRUE"
+                )
+
+        if major == "0" and (int(minor) < 2 or
+                             (minor == "2" and int(release) < 10)):
+            if minor != "0":
+                execute(
+                    "ALTER TABLE geometry_profileXYZ " +
+                    "ADD COLUMN interpolated BOOLEAN NOT NULL DEFAULT FALSE"
+                )
+            execute(
+                "UPDATE geometry_profileXYZ " +
+                "SET interpolated = CASE " +
+                "WHEN LOWER(name) LIKE 'interpol%' THEN TRUE " +
+                "ELSE FALSE END"
+            )
+
         return cls._update_submodel(execute, version, data)
 
     @classmethod
@@ -234,7 +263,7 @@ class ProfileXYZ(Profile, SQLSubModel):
 
         table = execute(
             "SELECT pamhyr_id, ind, deleted, name, rk, num, " +
-            "code1, code2, sl, scenario " +
+            "code1, code2, sl, scenario, enabled, interpolated " +
             "FROM geometry_profileXYZ " +
             f"WHERE reach = {reach.id} " +
             f"AND scenario = {scenario.id} " +
@@ -255,6 +284,8 @@ class ProfileXYZ(Profile, SQLSubModel):
             code2 = next(it)
             sl = next(it)
             owner_scenario = next(it)
+            enabled = (next(it) == 1)
+            interpolated = (next(it) == 1)
 
             profile = cls(
                 id=pid, ind=ind, num=num,
@@ -262,7 +293,9 @@ class ProfileXYZ(Profile, SQLSubModel):
                 code1=code1, code2=code2,
                 reach=reach,
                 status=status,
-                owner_scenario=owner_scenario
+                owner_scenario=owner_scenario,
+                enabled=enabled,
+                interpolated=interpolated
             )
             if deleted:
                 profile.set_as_deleted()
@@ -315,12 +348,14 @@ class ProfileXYZ(Profile, SQLSubModel):
         execute(
             "INSERT OR REPLACE INTO " +
             "geometry_profileXYZ(pamhyr_id, deleted, ind, name, reach, " +
-            "rk, num, code1, code2, sl, scenario) " +
+            "rk, num, code1, code2, sl, scenario, enabled, interpolated) " +
             "VALUES (" +
             f"{self.pamhyr_id}, {self._db_format(self.is_deleted())}, " +
             f"{ind}, '{self._db_format(self._name)}', " +
             f"{self.reach.pamhyr_id}, {self.rk}, {self.num}, " +
-            f"{self.code1}, {self.code1}, {sl}, {self._status.scenario_id}" +
+            f"{self.code1}, {self.code1}, {sl}, {self._status.scenario_id}, " +
+            f"{self._db_format(self._enabled)}, " +
+            f"{self._db_format(self._interpolated)}" +
             ")"
         )
 
@@ -387,7 +422,9 @@ class ProfileXYZ(Profile, SQLSubModel):
             name=self.name,
             rk=self.rk,
             reach=self.reach,
-            status=self._status
+            status=self._status,
+            enabled=self.is_enabled,
+            interpolated=self.interpolated
         )
         if self.is_deleted():
             new_p.set_as_deleted()
@@ -407,7 +444,9 @@ class ProfileXYZ(Profile, SQLSubModel):
             name=self.name,
             rk=self.rk,
             reach=new_reach,
-            status=self._status
+            status=self._status,
+            enabled=self.is_enabled,
+            interpolated=self.interpolated
         )
         if self.is_deleted():
             new_p.set_as_deleted()
@@ -520,7 +559,7 @@ class ProfileXYZ(Profile, SQLSubModel):
             )
             self._points.append(pt)
 
-        self.modified()
+        self.content_modified()
 
     def get_point_i(self, index: int) -> PointXYZ:
         """Get point at index.
@@ -585,7 +624,7 @@ class ProfileXYZ(Profile, SQLSubModel):
         )
         self.points.append(point_xyz)
 
-        self.modified()
+        self.content_modified()
 
     def insert(self, index: int):
         """Insert a new point at index.
@@ -604,7 +643,7 @@ class ProfileXYZ(Profile, SQLSubModel):
         point = PointXYZ(x=x, y=y, z=z, profile=self, status=self._status)
         self._points.insert(index, point)
 
-        self.modified()
+        self.content_modified()
 
         return point
 
@@ -619,6 +658,7 @@ class ProfileXYZ(Profile, SQLSubModel):
         """
         return [x for x in lst if not np.isnan(x)]
 
+    @timer
     def speed(self, q, z):
         area = self.wet_area(z)
 
@@ -670,6 +710,7 @@ class ProfileXYZ(Profile, SQLSubModel):
             length += line.length
         return length
 
+    @timer
     def compute_wet_area(self, z):
         area = 0.0
         if len(self.tab.L) > 0:
@@ -710,6 +751,7 @@ class ProfileXYZ(Profile, SQLSubModel):
                 if len(line.coords) > 2:
                     poly = geometry.Polygon(line)
                     area += poly.area
+
         return area
 
     def wet_radius(self, z):
@@ -732,6 +774,7 @@ class ProfileXYZ(Profile, SQLSubModel):
         line = geometry.LineString(list(zip(station, zz)))
         return line
 
+    @timer
     def wet_lines(self, z):
         points = self._points
         if len(points) < 3:
@@ -808,7 +851,6 @@ class ProfileXYZ(Profile, SQLSubModel):
         return points
 
     def get_nb_wet_areas(self, z):
-
         n_zones = 0
         points = self._points
         if points[0].z <= z:
@@ -820,10 +862,13 @@ class ProfileXYZ(Profile, SQLSubModel):
 
         return n_zones
 
+    @timer
     def get_all_water_limits_ac(self, z):
         """
         Determine all water limits for z elevation.
         """
+        if z in self._get_water_limits_ac_cache:
+            return self._get_water_limits_ac_cache[z]
 
         points = self._points
         if len(points) < 3:
@@ -856,69 +901,94 @@ class ProfileXYZ(Profile, SQLSubModel):
             logger.error(f"ERROR in get_all_water_limits_ac")
             return [], []
 
-        return start, list(reversed(end))
+        res = start, list(reversed(end))
+        self._get_water_limits_ac_cache[z] = res
 
+        return res
+
+    @timer
     def get_water_limits(self, z):
+        if z in self._get_water_limits_cache:
+            return self._get_water_limits_cache[z]
+
+        v = self.get_water_limits_compute(z)
+
+        return v
+
+    def get_water_limits_compute(self, z):
         """
         Determine left and right limits of water elevation.
         """
-
         # Get the index of first point with elevation lesser than water
         # elevation (for the right and left river side)
-        i_left = -1
+        i_left = next(
-        i_right = -1
+            filter(
+                lambda i: self.point(i).z <= z,
+                range(self.number_points)
+            ),
+            -1
+        )
 
-        for i in range(self.number_points):
+        i_right = next(
-            if self.point(i).z <= z:
+            filter(
-                i_left = i
+                lambda i: self.point(i).z <= z,
-                break
+                reversed(range(self.number_points))
-
+            ),
-        for i in reversed(range(self.number_points)):
+            -1
-            if self.point(i).z <= z:
+        )
-                i_right = i
-                break
 
         # Interpolate points at river left side
         if (i_left > 0):
-            if abs(self.point(i_left - 1).z - self.point(i_left).z) < 1e-20:
+            pi = self.point(i_left)
-                pt_left = self.point(i_left)
+            pim1 = self.point(i_left - 1)
+
+            if abs(pim1.z - pi.z) < 1e-20:
+                pt_left = pi
             else:
-                fact = (z - self.point(i_left).z) / \
+                fact = (z - pi.z) / (pim1.z - pi.z)
-                    (self.point(i_left - 1).z - self.point(i_left).z)
+                x = pi.x + fact * (pim1.x - pi.x)
-                x = self.point(i_left).x + fact * \
+                y = pi.y + fact * (pim1.y - pi.y)
-                    (self.point(i_left - 1).x - self.point(i_left).x)
-                y = self.point(i_left).y + fact * \
-                    (self.point(i_left - 1).y - self.point(i_left).y)
                 pt_left = PointXYZ(x=x, y=y, z=z, name="wl_left")
         else:
             pt_left = self.point(0)
 
         # Interpolate points at river right side
         if (i_right < self.number_points - 1):
-            if abs(self.point(i_right + 1).z - self.point(i_right).z) < 1e-20:
+            pi = self.point(i_right)
-                pt_right = self.point(i_right)
+            pip1 = self.point(i_right + 1)
+
+            if abs(pip1.z - pi.z) < 1e-20:
+                pt_right = pi
             else:
-                fact = (z - self.point(i_right).z) / \
+                fact = (z - pi.z) / (pip1.z - pi.z)
-                    (self.point(i_right + 1).z - self.point(i_right).z)
+                x = pi.x + fact * (pip1.x - pi.x)
-                x = self.point(i_right).x + fact * \
+                y = pi.y + fact * (pip1.y - pi.y)
-                    (self.point(i_right + 1).x - self.point(i_right).x)
-                y = self.point(i_right).y + fact * \
-                    (self.point(i_right + 1).y - self.point(i_right).y)
                 pt_right = PointXYZ(x=x, y=y, z=z, name="wl_right")
         else:
             pt_right = self.point(self.number_points - 1)
 
-        return pt_left, pt_right
+        v = (pt_left, pt_right)
 
+        # Put results in cache
+        self._get_water_limits_cache[z] = v
+
+        # Create a generator to improve results data reading speed
+        yield v
+
+    @timer
     def compute_tabulation(self):
         sorted_points = sorted(self._points, key=lambda p: p.z)
+
         self.tab.z = np.array([p.z for p in sorted_points], np.float64)
         self.tab.L = np.zeros(len(self.tab.z), np.float64)
         self.tab.A = np.zeros(len(self.tab.z), np.float64)
+
         for i in range(1, len(self.tab.z)):
             self.tab.L[i] = self.compute_wet_width(self.tab.z[i])
+
             dx = (self.tab.L[i] + self.tab.L[i-1])/2
             dz = self.tab.z[i] - self.tab.z[i-1]
+
             self.tab.A[i] = self.tab.A[i-1] + dz * dx
 
         self.tab_up_to_date = True
@@ -933,7 +1003,7 @@ class ProfileXYZ(Profile, SQLSubModel):
             Projection of the points of the profile on a plane.
         """
         if self.nb_points < 2:
-            return [0.0]
+            return [0.0] * self.nb_points
         else:
             if self.station_up_to_date:
                 return self._station
@@ -1097,11 +1167,14 @@ class ProfileXYZ(Profile, SQLSubModel):
         p = ProfileXYZ(name=self.name,
                        rk=self.rk,
                        reach=self.reach,
-                       status=self._status)
+                       status=self._status,
+                       enabled=self.is_enabled,
+                       interpolated=self.interpolated)
 
         for i, k in enumerate(self.points):
-            p.insert_point(i, k.copy())
+            p.insert_point(i, k.cloned_for(p))
 
+        p._interpolated = self.interpolated
         return p
 
     def purge_aligned_points(self):
@@ -1131,3 +1204,25 @@ class ProfileXYZ(Profile, SQLSubModel):
                     break
         self._points = points
         self.modified()
+
+    @property
+    def is_enabled(self):
+        return self._enabled
+
+    @property
+    def enabled(self):
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, value):
+        self._enabled = bool(value)
+        self.modified()
+
+    @property
+    def interpolated(self):
+        return self._interpolated
+
+    @interpolated.setter
+    def interpolated(self, value):
+        self._interpolated = bool(value)
+        self.modified()

src/Model/Geometry/Reach.py

@@ -1,5 +1,5 @@
 # Reach.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -80,11 +80,13 @@ class Reach(SQLSubModel):
     @classmethod
     def _db_load(cls, execute, data=None):
         new = cls(status=data["status"], parent=data["reach"])
+        profile_data = data.copy()
+        profile_data["reach"] = new
 
         new._profiles = sorted(
             ProfileXYZ._db_load(
                 execute,
-                data=data.copy()
+                data=profile_data
             ),
             key=lambda p: p._db_ind
         )
@@ -157,6 +159,14 @@ class Reach(SQLSubModel):
     def profiles(self, profiles):
         self._profiles = profiles
 
+    @property
+    def enabled_profiles(self):
+        return list(filter(lambda p: p.is_enabled, self.profiles))
+
+    @property
+    def number_enabled_profiles(self):
+        return len(self.enabled_profiles)
+
     def get_profiles_from_rk(self, rk):
         return list(
             filter(
@@ -367,6 +377,28 @@ class Reach(SQLSubModel):
             )
         )
 
+    def get_z_min_enabled_profiles(self):
+        return list(
+            map(
+                lambda profile: profile.z_min(),
+                filter(
+                    lambda profile: len(profile) > 0 and profile.is_enabled,
+                    self.profiles
+                )
+            )
+        )
+
+    def get_z_max_enabled_profiles(self):
+        return list(
+            map(
+                lambda profile: profile.z_max(),
+                filter(
+                    lambda profile: len(profile) > 0 and profile.is_enabled,
+                    self.profiles
+                )
+            )
+        )
+
     def get_rk(self):
         """List of profiles rk
 
@@ -375,6 +407,17 @@ class Reach(SQLSubModel):
         """
         return [profile.rk for profile in self.profiles]
 
+    def get_rk_enabled_profiles(self):
+        return list(
+            map(
+                lambda profile: profile.rk,
+                filter(
+                    lambda profile: len(profile) > 0 and profile.is_enabled,
+                    self.profiles
+                )
+            )
+        )
+
     def get_rk_complete_profiles(self):
         return list(
             map(
@@ -486,14 +529,22 @@ class Reach(SQLSubModel):
             )
 
     @timer
-    def compute_guidelines(self):
+    def compute_guidelines(self, profiles=None, update_cache=True):
         """Compute reach guidelines
 
+        Args:
+            profiles: Profiles used to compute the guidelines. If omitted,
+                all non-deleted profiles of the reach are used.
+            update_cache: Whether to update the reach guidelines cache.
+
         Returns:
             Tuple of complete and incomplete guidelines name.
         """
+        if profiles is None:
+            profiles = self.profiles
+
         # Get all point contained into a guideline
-        named_points = [profile.named_points() for profile in self.profiles]
+        named_points = [profile.named_points() for profile in profiles]
         points_name = list(
             map(
                 lambda lst: list(map(lambda p: p.name, lst)),
@@ -524,11 +575,13 @@ class Reach(SQLSubModel):
 
         complete = guide_set - incomplete
 
-        # Compute guideline and put data in cache
+        if update_cache:
-        self._compute_guidelines_cache(guide_set, named_points,
+            # Compute guideline and put data in cache
-                                       complete, incomplete)
+            self._compute_guidelines_cache(
+                guide_set, named_points, complete, incomplete
+            )
+            self.modified()
 
-        self.modified()
         return (complete, incomplete)
 
     def _map_guidelines_points(self, func, full=False):
@@ -752,8 +805,11 @@ class Reach(SQLSubModel):
                                 list_profile.append(list_point_profile)
                                 list_point_profile = []
                             else:
-                                line.append("")
+                                # MAGE-8 ST files can append hydraulic data
-                                list_point_profile.append(line[:3])
+                                # after the regular x, y, z and point-name
+                                # fields.  ProfileXYZ still expects exactly
+                                # those first four fields.
+                                list_point_profile.append(line[:4])
                         else:
                             pass
 

src/Model/Geometry/Vector_1d.py

@@ -1,5 +1,5 @@
 # Vector_1d.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/HydraulicStructures/Basic/HydraulicStructures.py

@@ -1,5 +1,5 @@
 # HydraulicStructures.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -277,3 +277,10 @@ class BasicHS(SQLSubModel):
 
     def convert(self, new_type):
         return new_type(id=self.id, name=self.name, status=self._status)
+
+    def cloned(self):
+        new = type(self)(name=self._name, status=self._status)
+        new._enabled = self._enabled
+        new._data = [value.cloned() for value in self._data]
+        new.modified()
+        return new

src/Model/HydraulicStructures/Basic/Types.py

@@ -1,5 +1,5 @@
 # Types.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/HydraulicStructures/Basic/Value.py

@@ -1,5 +1,5 @@
 # Value.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -208,3 +208,11 @@ class BHSValue(SQLSubModel):
     def value(self, value):
         self._value = self._type(value)
         self.modified()
+
+    def cloned(self):
+        return BHSValue(
+            name=self._name,
+            type=self._type,
+            value=self._value,
+            status=self._status
+        )

src/Model/HydraulicStructures/HydraulicStructures.py

@@ -1,5 +1,5 @@
 # HydraulicStructures.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -47,9 +47,7 @@ class HydraulicStructure(SQLSubModel):
 
         self._name = name
         self._input_section = None
-        self._output_section = None
         self._input_reach = None
-        self._output_reach = None
         self._enabled = True
         self._data = []
 
@@ -62,17 +60,12 @@ class HydraulicStructure(SQLSubModel):
             name TEXT NOT NULL,
             enabled BOOLEAN NOT NULL,
             input_reach INTEGER,
-            output_reach INTEGER,
             input_section INTEGER,
-            output_section INTEGER,
             {Scenario.create_db_add_scenario()},
             {Scenario.create_db_add_scenario_fk()},
             FOREIGN KEY(input_reach) REFERENCES river_reach(pamhyr_id),
-            FOREIGN KEY(output_reach) REFERENCES river_reach(pamhyr_id),
             FOREIGN KEY(input_section)
               REFERENCES geometry_profileXYZ(pamhyr_id),
-            FOREIGN KEY(output_section)
-              REFERENCES geometry_profileXYZ(pamhyr_id),
             PRIMARY KEY(pamhyr_id, scenario)
           )
         """)
@@ -92,13 +85,12 @@ class HydraulicStructure(SQLSubModel):
                 return True
 
             if rl < 11:
-                for v in ["input", "output"]:
+                execute(
-                    execute(
+                    """
-                        f"""
+                    ALTER TABLE hydraulic_structures
-                        ALTER TABLE hydraulic_structures
+                    RENAME COLUMN input_kp TO input_rk
-                        RENAME COLUMN {v}_kp TO {v}_rk
+                    """
-                        """
+                )
-                    )
 
             cls._db_update_to_0_2_0(execute, data)
 
@@ -112,8 +104,28 @@ class HydraulicStructure(SQLSubModel):
                     "ADD COLUMN deleted BOOLEAN NOT NULL DEFAULT FALSE"
                 )
 
+        if major == "0" and (int(minor) < 2 or
+                             (minor == "2" and rl < 10)):
+            cls._db_update_to_0_2_10(execute)
+
         return cls._update_submodel(execute, version, data)
 
+    @classmethod
+    def _db_update_to_0_2_10(cls, execute):
+        table = "hydraulic_structures"
+        cls._db_create(execute, ext="_tmp")
+
+        execute(
+            f"INSERT INTO {table}_tmp " +
+            "(pamhyr_id, deleted, name, enabled, input_section, " +
+            "input_reach, scenario) " +
+            "SELECT pamhyr_id, deleted, name, enabled, input_section, " +
+            f"input_reach, scenario FROM {table}"
+        )
+
+        execute(f"DROP TABLE {table}")
+        execute(f"ALTER TABLE {table}_tmp RENAME TO {table}")
+
     @classmethod
     def _db_update_to_0_2_0(cls, execute, data):
         table = "hydraulic_structures"
@@ -131,11 +143,10 @@ class HydraulicStructure(SQLSubModel):
 
         execute(
             f"INSERT INTO {table}_tmp " +
-            "(pamhyr_id, name, enabled, input_section, output_section, " +
+            "(pamhyr_id, name, enabled, input_section, " +
-            "input_reach, output_reach, scenario) " +
+            "input_reach, scenario) " +
             "SELECT pamhyr_id, name, enabled, " +
-            "input_section, output_section, " +
+            "input_section, input_reach, scenario " +
-            "input_reach, output_reach, scenario " +
             f"FROM {table}"
         )
 
@@ -145,44 +156,38 @@ class HydraulicStructure(SQLSubModel):
     @classmethod
     def _db_update_to_0_2_0_set_reach_pid(cls, execute, table, reachs):
         els = execute(
-            f"SELECT pamhyr_id, input_reach, output_reach FROM {table}"
+            f"SELECT pamhyr_id, input_reach FROM {table}"
         )
 
         for row in els:
             it = iter(row)
             pid = next(it)
             in_reach_id = next(it)
-            out_reach_id = next(it)
 
             if in_reach_id == -1:
                 return
 
-            if out_reach_id == -1:
-                out_reach_id = in_reach_id
-
             execute(
                 f"UPDATE {table} " +
-                f"SET input_reach = {reachs[in_reach_id]}, " +
+                f"SET input_reach = {reachs[in_reach_id]} " +
-                f"output_reach = {reachs[out_reach_id]} " +
                 f"WHERE pamhyr_id = {pid}"
             )
 
     @classmethod
     def _db_update_to_0_1_1(cls, execute, data,
                             origin_version="0.1.0"):
-        for v in ["input", "output"]:
+        execute(
-            execute(
+            "ALTER TABLE hydraulic_structures " +
-                "ALTER TABLE hydraulic_structures " +
+            "ADD COLUMN input_section INTEGER"
-                f"ADD COLUMN {v}_section INTEGER"
+        )
-            )
 
-            cls._db_update_to_0_1_1_assoc_section_from_rk(
+        cls._db_update_to_0_1_1_assoc_section_from_rk(
-                execute, "hydraulic_structures",
+            execute, "hydraulic_structures",
-                reach_column=f"{v}_reach",
+            reach_column="input_reach",
-                rk_column=f"{v}_rk",
+            rk_column="input_rk",
-                section_column=f"{v}_section",
+            section_column="input_section",
-                origin_version=origin_version
+            origin_version=origin_version
-            )
+        )
 
     @classmethod
     def _db_load(cls, execute, data=None):
@@ -196,8 +201,7 @@ class HydraulicStructure(SQLSubModel):
 
         table = execute(
             "SELECT pamhyr_id, deleted, name, enabled, " +
-            "input_section, output_section, " +
+            "input_section, input_reach, scenario " +
-            "input_reach, output_reach, scenario " +
             "FROM hydraulic_structures " +
             f"WHERE scenario = {scenario.id} " +
             f"AND pamhyr_id NOT IN ({', '.join(map(str, loaded))})"
@@ -227,12 +231,7 @@ class HydraulicStructure(SQLSubModel):
         input_section_id = (
             -1 if input_section_id is None else input_section_id
         )
-        output_section_id = next(it)
-        output_section_id = (
-            -1 if output_section_id is None else output_section_id
-        )
         input_reach_id = next(it)
-        output_reach_id = next(it)
         owner_scenario = next(it)
 
         hs = cls(
@@ -243,27 +242,19 @@ class HydraulicStructure(SQLSubModel):
             hs.set_as_deleted()
 
         hs.enabled = enabled
-        hs.input_reach, hs.output_reach = reduce(
+        hs.input_reach = reduce(
-            lambda acc, n: (
+            lambda acc, n: n if n.pamhyr_id == input_reach_id else acc,
-                n if n.pamhyr_id == input_reach_id else acc[0],
-                n if n.pamhyr_id == output_reach_id else acc[1]
-            ),
             data["edges"],
-            [None, None]
+            None
         )
         sections = []
         if hs.input_reach is not None:
             sections += hs.input_reach.reach.profiles
-        if hs.output_reach is not None:
-            sections += hs.output_reach.reach.profiles
 
-        hs.input_section, hs.output_section = reduce(
+        hs.input_section = reduce(
-            lambda acc, s: (
+            lambda acc, s: s if s.pamhyr_id == input_section_id else acc,
-                s if s.pamhyr_id == input_section_id else acc[0],
-                s if s.pamhyr_id == output_section_id else acc[1]
-            ),
             sections,
-            [None, None]
+            None
         )
 
         loaded.add(hs_id)
@@ -287,24 +278,15 @@ class HydraulicStructure(SQLSubModel):
         if self._input_reach is not None:
             input_reach_id = self._input_reach.pamhyr_id
 
-        output_reach_id = -1
-        if self._output_reach is not None:
-            output_reach_id = self._output_reach.pamhyr_id
-
         input_section = 'NULL'
         if self.input_section is not None:
             input_section = self.input_section.pamhyr_id
 
-        output_section = 'NULL'
-        if self.output_section is not None:
-            output_section = self.output_section.pamhyr_id
-
         execute(
             "INSERT INTO " +
             "hydraulic_structures(" +
             "  pamhyr_id, deleted, name, enabled, " +
-            "  input_section, output_section, " +
+            "  input_section, input_reach, " +
-            "  input_reach, output_reach, " +
             "  scenario" +
             ") " +
             "VALUES (" +
@@ -312,8 +294,7 @@ class HydraulicStructure(SQLSubModel):
             f"{self._db_format(self.is_deleted())}, " +
             f"'{self._db_format(self._name)}', " +
             f"{self._db_format(self.enabled)}, " +
-            f"{input_section}, {output_section}, " +
+            f"{input_section}, {input_reach_id}, " +
-            f"{input_reach_id}, {output_reach_id}, " +
             f"{self._status.scenario_id}"
             ")"
         )
@@ -371,13 +352,6 @@ class HydraulicStructure(SQLSubModel):
 
         return self._input_section
 
-    @property
-    def output_rk(self):
-        if self._output_section is None:
-            return None
-
-        return self._output_section
-
     @property
     def input_section(self):
         return self._input_section
@@ -387,15 +361,6 @@ class HydraulicStructure(SQLSubModel):
         self._input_section = input_section
         self.modified()
 
-    @property
-    def output_section(self):
-        return self._output_section
-
-    @output_section.setter
-    def output_section(self, output_section):
-        self._output_section = output_section
-        self.modified()
-
     @property
     def enabled(self):
         return self._enabled
@@ -414,19 +379,19 @@ class HydraulicStructure(SQLSubModel):
         self._input_reach = input_reach
         self.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.modified()
-
     @property
     def basic_structures(self):
         return self.lst.copy()
 
+    def cloned_for(self, input_reach, input_section):
+        new = HydraulicStructure(name=self._name, status=self._status)
+        new._enabled = self._enabled
+        new._input_reach = input_reach
+        new._input_section = input_section
+        new._data = [structure.cloned() for structure in self.lst]
+        new.modified()
+        return new
+
     def basic_structure(self, index: int):
         if len(self._data) == 0:
             return None

src/Model/HydraulicStructures/HydraulicStructuresList.py

@@ -1,5 +1,5 @@
 # HydraulicStructuresList.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -61,6 +61,64 @@ class HydraulicStructureList(PamhyrModelList):
         self.modified()
         return n
 
+    def split_reach(self, reach, profile, reach1, reach2):
+        profiles = reach.reach.profiles
+        split_index = profiles.index(profile)
+        sections1 = dict(zip(
+            profiles[:split_index + 1],
+            reach1.reach.profiles
+        ))
+        sections2 = dict(zip(
+            profiles[split_index:],
+            reach2.reach.profiles
+        ))
+
+        def split_endpoint(endpoint_reach, section):
+            if endpoint_reach is not reach:
+                return endpoint_reach, section
+            if section not in profiles:
+                return endpoint_reach, section
+
+            index = profiles.index(section)
+            if index < split_index:
+                return reach1, sections1[section]
+            return reach2, sections2[section]
+
+        structures = [
+            structure
+            for structure in self.lst
+            if structure.input_reach is reach
+        ]
+
+        for structure in structures:
+            input_reach, input_section = split_endpoint(
+                structure.input_reach,
+                structure.input_section
+            )
+            self._lst.append(structure.cloned_for(
+                input_reach,
+                input_section
+            ))
+
+        if len(structures) != 0:
+            self.modified()
+
+    @property
+    def enabled_reaches_list(self):
+        return [
+            structure
+            for structure in self.lst
+            if (structure.input_reach is None or
+                (not structure.input_reach.is_deleted() and
+                 structure.input_reach.is_enable()))
+        ]
+
+    def get_for_enabled_reaches(self, index):
+        structures = self.enabled_reaches_list
+        if not 0 <= index < len(structures):
+            return None
+        return structures[index]
+
     def __copy__(self):
         new = HydraulicStructureList()
 

src/Model/InitialConditions/InitialConditions.py

@@ -1,5 +1,5 @@
 # InitialConditions.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -19,6 +19,7 @@
 import logging
 
 from copy import copy, deepcopy
+from math import isclose
 from tools import trace, timer
 from functools import reduce
 from numpy import interp
@@ -256,6 +257,17 @@ class Data(SQLSubModel):
         )
         return new
 
+    def cloned_for(self, reach, section):
+        return Data(
+            name=self._name,
+            comment=self._comment,
+            section=section,
+            discharge=self._discharge,
+            height=self._height,
+            reach=reach,
+            status=self._status,
+        )
+
     @property
     def name(self):
         return self._name
@@ -428,15 +440,28 @@ class InitialConditions(SQLSubModel):
 
     def new_from_data(self, rk, discharge, elevation):
         n = Data(reach=self._reach, status=self._status)
+        # Values read from Mage INI files are strings, whereas profile RK
+        # values are stored as floats.  Normalize the imported value before
+        # looking up its associated profile.
+        rk = float(rk)
 
         section = reduce(
             lambda acc, s: (
-                s if s.rk == rk else acc
+                # Mage INI files store RK values with two decimal places.
+                # Allow for the rounding introduced by that format.
+                s if isclose(s.rk, rk, rel_tol=0.0, abs_tol=0.0051)
+                else acc
             ),
             self._reach.reach.profiles,
             None
         )
 
+        if section is None:
+            raise ValueError(
+                f"No profile with RK {rk} exists in reach "
+                f"{self._reach.name}"
+            )
+
         n['section'] = section
         n['discharge'] = discharge
         n['elevation'] = elevation
@@ -505,6 +530,20 @@ class InitialConditions(SQLSubModel):
         for data in self._data:
             data.set_as_deleted()
 
+    def _splited_for(self, reach, sections):
+        new = InitialConditions(reach=reach, status=self._status)
+
+        new._data = [
+            data.cloned_for(reach, sections[data["section"]])
+            for data in self.data
+            if data["section"] in sections
+        ]
+
+        if len(new._data) != 0:
+            new.modified()
+
+        return new
+
     def generate_growing_constant_depth(self, height: float,
                                         compute_discharge: bool):
         profiles = self._reach.reach.profiles.copy()

src/Model/InitialConditions/InitialConditionsDict.py

@@ -1,5 +1,5 @@
 # InitialConditionsDict.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -88,3 +88,28 @@ class InitialConditionsDict(PamhyrModelDict):
         new = InitialConditions(reach=reach, status=self._status)
         self.set(reach, new)
         return new
+
+    def split_reach(self, reach, profile, reach1, reach2):
+        if reach not in self._dict:
+            return
+
+        profiles = reach.reach.profiles
+        split_index = profiles.index(profile)
+
+        sections1 = dict(zip(
+            profiles[:split_index + 1],
+            reach1.reach.profiles
+        ))
+        sections2 = dict(zip(
+            profiles[split_index:],
+            reach2.reach.profiles
+        ))
+
+        self.set(
+            reach1,
+            self._dict[reach]._splited_for(reach1, sections1)
+        )
+        self.set(
+            reach2,
+            self._dict[reach]._splited_for(reach2, sections2)
+        )

src/Model/InitialConditionsAdisTS/InitialConditionsAdisTS.py

@@ -1,5 +1,5 @@
 # InitialConditionsAdisTS.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -359,3 +359,60 @@ class InitialConditionsAdisTS(SQLSubModel):
             x.set_as_not_deleted()
 
         self.modified()
+
+    def split_reach(self, reach, profile, reach1, reach2):
+        split_rk = profile.rk
+        reach_rks = reach.reach.get_rk()
+        if len(reach_rks) == 0:
+            return
+
+        lower_reach_rk = min(reach_rks)
+        upper_reach_rk = max(reach_rks)
+        parts = [
+            (reach1.id, lower_reach_rk, split_rk),
+            (reach2.id, split_rk, upper_reach_rk),
+        ]
+        specifications = [
+            specification
+            for specification in self._data
+            if (not specification.is_deleted() and
+                specification.reach == reach.id)
+        ]
+
+        for specification in specifications:
+            begin = specification.start_rk
+            end = specification.end_rk
+            if begin is None or end is None:
+                continue
+
+            lower, upper = sorted((begin, end))
+            reverse = begin > end
+
+            for new_reach, part_lower, part_upper in parts:
+                clipped_lower = max(lower, part_lower)
+                clipped_upper = min(upper, part_upper)
+                if clipped_lower >= clipped_upper:
+                    continue
+
+                start_rk = clipped_upper if reverse else clipped_lower
+                end_rk = clipped_lower if reverse else clipped_upper
+                self._data.append(specification.cloned_for(
+                    new_reach, start_rk, end_rk
+                ))
+
+        if len(specifications) != 0:
+            self.modified()
+
+    def get_specs_for_enabled_reaches(self, reaches):
+        enabled_reaches = {
+            reach.id
+            for reach in reaches
+            if not reach.is_deleted() and reach.is_enable()
+        }
+        return [
+            specification
+            for specification in self._data
+            if (not specification.is_deleted() and
+                (specification.reach in (None, -1) or
+                 specification.reach in enabled_reaches))
+        ]

src/Model/InitialConditionsAdisTS/InitialConditionsAdisTSList.py

@@ -1,5 +1,5 @@
 # InitialConditionsAdisTSList.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -62,6 +62,12 @@ class InitialConditionsAdisTSList(PamhyrModelList):
         self._status.modified()
         return n
 
+    def split_reach(self, reach, profile, reach1, reach2):
+        for initial_condition in self.lst:
+            initial_condition.split_reach(
+                reach, profile, reach1, reach2
+            )
+
     @property
     def Initial_Conditions_List(self):
         return self.lst

src/Model/InitialConditionsAdisTS/InitialConditionsAdisTSSpec.py

@@ -1,5 +1,5 @@
 # InitialConditionsAdisTSSpec.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -31,10 +31,12 @@ class ICAdisTSSpec(SQLSubModel):
     _sub_classes = []
 
     def __init__(self, id: int = -1, name: str = "",
-                 status=None, owner_scenario=None):
+                 status=None, owner_scenario=-1):
-        super(ICAdisTSSpec, self).__init__()
+        super(ICAdisTSSpec, self).__init__(
-
+            id=id,
-        self._status = status
+            status=status,
+            owner_scenario=owner_scenario
+        )
 
         self._name_section = name
         self._reach = None
@@ -190,7 +192,7 @@ class ICAdisTSSpec(SQLSubModel):
                 new_spec.rate = rate
                 new_spec.enabled = enabled
 
-                # loaded.add(pid)
+                loaded.add(id)
                 new.append(new_spec)
 
         data["scenario"] = scenario.parent
@@ -234,7 +236,8 @@ class ICAdisTSSpec(SQLSubModel):
     @name.setter
     def name(self, name):
         self._name_section = name
-        self._status.modified()
+        self.modified()
+        self.modified()
 
     @property
     def reach(self):
@@ -243,7 +246,8 @@ class ICAdisTSSpec(SQLSubModel):
     @reach.setter
     def reach(self, reach):
         self._reach = reach
-        self._status.modified()
+        self.modified()
+        self.modified()
 
     @property
     def start_rk(self):
@@ -252,7 +256,8 @@ class ICAdisTSSpec(SQLSubModel):
     @start_rk.setter
     def start_rk(self, start_rk):
         self._start_rk = start_rk
-        self._status.modified()
+        self.modified()
+        self.modified()
 
     @property
     def end_rk(self):
@@ -261,7 +266,8 @@ class ICAdisTSSpec(SQLSubModel):
     @end_rk.setter
     def end_rk(self, end_rk):
         self._end_rk = end_rk
-        self._status.modified()
+        self.modified()
+        self.modified()
 
     @property
     def concentration(self):
@@ -270,7 +276,8 @@ class ICAdisTSSpec(SQLSubModel):
     @concentration.setter
     def concentration(self, concentration):
         self._concentration = concentration
-        self._status.modified()
+        self.modified()
+        self.modified()
 
     @property
     def eg(self):
@@ -279,7 +286,8 @@ class ICAdisTSSpec(SQLSubModel):
     @eg.setter
     def eg(self, eg):
         self._eg = eg
-        self._status.modified()
+        self.modified()
+        self.modified()
 
     @property
     def em(self):
@@ -288,7 +296,8 @@ class ICAdisTSSpec(SQLSubModel):
     @em.setter
     def em(self, em):
         self._em = em
-        self._status.modified()
+        self.modified()
+        self.modified()
 
     @property
     def ed(self):
@@ -297,7 +306,8 @@ class ICAdisTSSpec(SQLSubModel):
     @ed.setter
     def ed(self, ed):
         self._ed = ed
-        self._status.modified()
+        self.modified()
+        self.modified()
 
     @property
     def rate(self):
@@ -306,7 +316,8 @@ class ICAdisTSSpec(SQLSubModel):
     @rate.setter
     def rate(self, rate):
         self._rate = rate
-        self._status.modified()
+        self.modified()
+        self.modified()
 
     @property
     def enabled(self):
@@ -315,4 +326,18 @@ class ICAdisTSSpec(SQLSubModel):
     @enabled.setter
     def enabled(self, enabled):
         self._enabled = enabled
-        self._status.modified()
+        self.modified()
+
+    def cloned_for(self, reach, start_rk, end_rk):
+        new = ICAdisTSSpec(name=self._name_section, status=self._status)
+        new._reach = reach
+        new._start_rk = start_rk
+        new._end_rk = end_rk
+        new._concentration = self._concentration
+        new._eg = self._eg
+        new._em = self._em
+        new._ed = self._ed
+        new._rate = self._rate
+        new._enabled = self._enabled
+        new.modified()
+        return new

src/Model/InitialConditionsTemperature/InitialConditionsTemperature.py

@@ -0,0 +1,272 @@
+# InitialConditionsTemperature.py -- Pamhyr
+# Copyright (C) 2023-2025  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.Scenario import Scenario
+
+from Model.InitialConditionsTemperature.InitialConditionsTemperatureSpec \
+    import ICTemperatureSpec
+
+logger = logging.getLogger()
+
+
+class InitialConditionsTemperature(SQLSubModel):
+    _sub_classes = [
+        ICTemperatureSpec,
+    ]
+
+    def __init__(self, id: int = -1, name: str = "default",
+                 status=None, owner_scenario=-1):
+        super(InitialConditionsTemperature, self).__init__(
+            id=id, status=status,
+            owner_scenario=owner_scenario
+        )
+        self._status = status
+
+        self._name = name
+        self._temperature = None
+        self._data = []
+
+    @classmethod
+    def _db_create(cls, execute, ext=""):
+        execute(f"""
+          CREATE TABLE initial_conditions_temperature{ext}(
+            {cls.create_db_add_pamhyr_id()},
+            deleted BOOLEAN NOT NULL DEFAULT FALSE,
+            name TEXT NOT NULL,
+            temperature REAL NOT NULL,
+            {Scenario.create_db_add_scenario()},
+            {Scenario.create_db_add_scenario_fk()}
+          )
+        """)
+
+        return cls._create_submodel(execute)
+
+    @classmethod
+    def _db_update(cls, execute, version, data=None):
+        major, minor, release = version.strip().split(".")
+
+        if major == "0":
+            if int(minor) < 2 or (int(minor) == 2 and int(release) <= 7):
+                table_name = "initial_conditions_temperature"
+                if not cls.is_table_exists(execute, table_name):
+                    cls._db_create(execute)
+
+        return cls._update_submodel(execute, version, data)
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = []
+        status = data['status']
+        scenario = data["scenario"]
+        loaded = data['loaded_pid']
+
+        if scenario is None:
+            return new
+
+        table = execute(
+            "SELECT pamhyr_id, deleted, " +
+            "name, temperature, scenario " +
+            "FROM initial_conditions_temperature " +
+            f"WHERE scenario = {scenario.id} " +
+            f"AND pamhyr_id NOT IN ({', '.join(map(str, loaded))})"
+        )
+
+        if table is not None:
+            for row in table:
+                it = iter(row)
+
+                pid = next(it)
+                deleted = (next(it) == 1)
+                name = next(it)
+                temperature = next(it)
+                owner_scenario = next(it)
+
+                ic = cls(
+                    id=pid,
+                    name=name,
+                    status=status,
+                    owner_scenario=owner_scenario
+                )
+                if deleted:
+                    ic.set_as_deleted()
+
+                ic.temperature = temperature
+
+                data['ic_default_id'] = pid
+                ic._data = ICTemperatureSpec._db_load(execute, data)
+
+                loaded.add(pid)
+                new.append(ic)
+
+        data["scenario"] = scenario.parent
+        new += cls._db_load(execute, data)
+        data["scenario"] = scenario
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        if not self.must_be_saved():
+            return True
+
+        execute(
+            "DELETE FROM initial_conditions_temperature " +
+            f"WHERE pamhyr_id = {self.id} " +
+            f"AND scenario = {self._status.scenario_id}"
+        )
+
+        temperature = self._temperature if \
+            self._temperature is not None else 0.0
+
+        sql = (
+            "INSERT INTO " +
+            "initial_conditions_temperature(" +
+            "pamhyr_id, deleted, name, temperature, " +
+            "scenario" +
+            ") " +
+            "VALUES (" +
+            f"{self.id}, {self.is_deleted()}, " +
+            f"'{self._db_format(self._name)}', " +
+            f"{temperature}, {self._status.scenario_id}" +
+            ")"
+        )
+
+        execute(sql)
+
+        data['ic_default_id'] = self.id
+        execute(
+            "DELETE FROM initial_conditions_temperature_spec " +
+            f"WHERE ic_default = {self.id} " +
+            f"AND scenario = {self._status.scenario_id}"
+        )
+
+        for ic_spec in self._data:
+            ic_spec._db_save(execute, data)
+
+        return True
+
+    def __len__(self):
+        return len(self.data)
+
+    @property
+    def data(self):
+        return list(filter(lambda item: not item.is_deleted(), self._data))
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, name):
+        self._name = name
+        self.modified()
+
+    @property
+    def temperature(self):
+        return self._temperature
+
+    @temperature.setter
+    def temperature(self, temperature):
+        self._temperature = temperature
+        self.modified()
+
+    def new(self, index):
+        n = ICTemperatureSpec(status=self._status)
+        self._data.insert(index, n)
+        self.modified()
+        return n
+
+    def delete(self, data):
+        list(
+            map(
+                lambda x: x.set_as_deleted(),
+                data
+            )
+        )
+        self.modified()
+
+    def delete_i(self, indexes):
+        list(
+            map(
+                lambda e: e[1].set_as_deleted(),
+                filter(
+                    lambda e: e[0] in indexes,
+                    enumerate(self._data)
+                )
+            )
+        )
+        self.modified()
+
+    def insert(self, index, data):
+        if data in self._data:
+            self.undelete([data])
+        else:
+            self._data.insert(index, data)
+
+        self.modified()
+
+    def undelete(self, lst):
+        for x in lst:
+            x.set_as_not_deleted()
+
+        self.modified()
+
+    def split_reach(self, reach, profile, reach1, reach2):
+        parts = []
+        for new_reach in (reach1, reach2):
+            rks = new_reach.reach.get_rk()
+            if rks:
+                parts.append((new_reach.id, min(rks), max(rks)))
+
+        specifications = [
+            specification
+            for specification in self._data
+            if (not specification.is_deleted() and
+                specification.reach == reach.id)
+        ]
+        clones = []
+
+        for specification in specifications:
+            begin = specification.start_rk
+            end = specification.end_rk
+            if begin is None or end is None:
+                continue
+
+            lower, upper = sorted((begin, end))
+            reverse = begin > end
+            for new_reach, part_lower, part_upper in parts:
+                clipped_lower = max(lower, part_lower)
+                clipped_upper = min(upper, part_upper)
+                if clipped_lower >= clipped_upper:
+                    continue
+
+                start_rk = clipped_upper if reverse else clipped_lower
+                end_rk = clipped_lower if reverse else clipped_upper
+                clones.append(specification.cloned_for(
+                    new_reach, start_rk, end_rk
+                ))
+
+        if clones:
+            self._data.extend(clones)
+            self.modified()

src/Model/InitialConditionsTemperature/InitialConditionsTemperatureList.py

@@ -0,0 +1,73 @@
+# InitialConditionsTemperatureList.py -- Pamhyr
+# Copyright (C) 2023-2025  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.PamhyrListExt import PamhyrModelList
+from Model.InitialConditionsTemperature.InitialConditionsTemperature \
+    import InitialConditionsTemperature
+
+
+class InitialConditionsTemperatureList(PamhyrModelList):
+    _sub_classes = [
+        InitialConditionsTemperature,
+    ]
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = cls(status=data['status'])
+
+        if data is None:
+            data = {}
+
+        new._lst = InitialConditionsTemperature._db_load(
+            execute, data
+        )
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        execute(
+            "DELETE FROM initial_conditions_temperature " +
+            f"WHERE scenario = {self._status.scenario_id}"
+        )
+
+        if data is None:
+            data = {}
+
+        for ic in self._lst:
+            ic._db_save(execute, data=data)
+
+        return True
+
+    def new(self, index):
+        n = InitialConditionsTemperature(status=self._status)
+        self._lst.insert(index, n)
+        self._status.modified()
+        return n
+
+    def split_reach(self, reach, profile, reach1, reach2):
+        for initial_condition in self.lst:
+            initial_condition.split_reach(
+                reach, profile, reach1, reach2
+            )
+
+    @property
+    def Initial_Conditions_List(self):
+        return self.lst

src/Model/InitialConditionsTemperature/InitialConditionsTemperatureSpec.py

@@ -0,0 +1,215 @@
+# InitialConditionsAdisTSSpec.py -- Pamhyr
+# Copyright (C) 2023-2025  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.Scenario import Scenario
+
+logger = logging.getLogger()
+
+
+class ICTemperatureSpec(SQLSubModel):
+    _sub_classes = []
+
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None, owner_scenario=-1):
+        super(ICTemperatureSpec, self).__init__(
+            id=id, status=status,
+            owner_scenario=owner_scenario
+        )
+
+        self._name_section = name
+        self._reach = None
+        self._start_rk = None
+        self._end_rk = None
+        self._temperature = None
+
+    @classmethod
+    def _db_create(cls, execute, ext=""):
+        execute(f"""
+          CREATE TABLE initial_conditions_temperature_spec{ext}(
+            {cls.create_db_add_pamhyr_id()},
+            deleted BOOLEAN NOT NULL DEFAULT FALSE,
+            ic_default INTEGER NOT NULL,
+            name TEXT NOT NULL,
+            reach INTEGER NOT NULL,
+            start_rk REAL NOT NULL,
+            end_rk REAL NOT NULL,
+            temperature REAL NOT NULL,
+            {Scenario.create_db_add_scenario()},
+            {Scenario.create_db_add_scenario_fk()},
+            FOREIGN KEY(ic_default)
+              REFERENCES initial_conditions_temperature(pamhyr_id),
+            FOREIGN KEY(reach) REFERENCES river_reach(pamhyr_id)
+          )
+        """)
+
+        return cls._create_submodel(execute)
+
+    @classmethod
+    def _db_update(cls, execute, version, data=None):
+        major, minor, release = version.strip().split(".")
+
+        if major == "0":
+            if int(minor) < 2 or (int(minor) == 2 and int(release) <= 7):
+                table_name = "initial_conditions_temperature_spec"
+                if not cls.is_table_exists(execute, table_name):
+                    cls._db_create(execute)
+
+        return True
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = []
+        status = data['status']
+        reachs = data["edges"]
+        scenario = data["scenario"]
+        loaded = data['loaded_pid']
+
+        if scenario is None:
+            return new
+
+        table = execute(
+            "SELECT pamhyr_id, deleted, name, reach, start_rk, end_rk, " +
+            "temperature, scenario " +
+            "FROM initial_conditions_temperature_spec " +
+            f"WHERE ic_default = {data['ic_default_id']} " +
+            f"AND scenario = {scenario.id} " +
+            f"AND pamhyr_id NOT IN ({', '.join(map(str, loaded))}) "
+        )
+
+        if table is not None:
+            for row in table:
+                it = iter(row)
+
+                id = next(it)
+                deleted = (next(it) == 1)
+                name = next(it)
+                reach = next(it)
+                start_rk = next(it)
+                end_rk = next(it)
+                temperature = next(it)
+                owner_scenario = next(it)
+
+                new_spec = cls(
+                    id=id, name=name,
+                    status=status,
+                    owner_scenario=owner_scenario
+                )
+                if deleted:
+                    new_spec.set_as_deleted()
+
+                new_spec.reach = reach
+                new_spec.start_rk = start_rk
+                new_spec.end_rk = end_rk
+                new_spec.temperature = temperature
+
+                loaded.add(id)
+                new.append(new_spec)
+
+        data["scenario"] = scenario.parent
+        new += cls._db_load(execute, data)
+        data["scenario"] = scenario
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        if not self.must_be_saved():
+            return True
+
+        ic_default = data['ic_default_id']
+
+        sql = (
+            "INSERT INTO " +
+            "initial_conditions_temperature_spec(pamhyr_id, deleted, " +
+            "ic_default, name, reach, " +
+            "start_rk, end_rk, temperature, scenario) " +
+            "VALUES (" +
+            f"{self.id}, {self._db_format(self.is_deleted())}, " +
+            f"{ic_default}, " +
+            f"'{self._db_format(self._name_section)}', " +
+            f"{self._reach}, " +
+            f"{self._start_rk}, {self._end_rk}, " +
+            f"{self._temperature}, " +
+            f"{self._status.scenario_id}" +
+            ")"
+        )
+        execute(sql)
+
+        return True
+
+    @property
+    def name(self):
+        return self._name_section
+
+    @name.setter
+    def name(self, name):
+        self._name_section = name
+        self.modified()
+
+    @property
+    def reach(self):
+        return self._reach
+
+    @reach.setter
+    def reach(self, reach):
+        self._reach = reach
+        self.modified()
+
+    @property
+    def start_rk(self):
+        return self._start_rk
+
+    @start_rk.setter
+    def start_rk(self, start_rk):
+        self._start_rk = start_rk
+        self.modified()
+
+    @property
+    def end_rk(self):
+        return self._end_rk
+
+    @end_rk.setter
+    def end_rk(self, end_rk):
+        self._end_rk = end_rk
+        self.modified()
+
+    @property
+    def temperature(self):
+        return self._temperature
+
+    @temperature.setter
+    def temperature(self, temperature):
+        self._temperature = temperature
+        self._status.modified()
+
+    def cloned_for(self, reach, start_rk, end_rk):
+        new = ICTemperatureSpec(
+            name=self._name_section,
+            status=self._status
+        )
+        new._reach = reach
+        new._start_rk = start_rk
+        new._end_rk = end_rk
+        new._temperature = self._temperature
+        new.modified()
+        return new

src/Model/LateralContribution/LateralContribution.py

@@ -1,5 +1,5 @@
 # LateralContribution.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -196,6 +196,13 @@ class Data(SQLSubModel):
     def __setitem__(self, key, value):
         self._data[key] = self._types[key](value)
 
+    def cloned(self):
+        return Data(
+            self[0], self[1],
+            types=self._types,
+            status=self._status
+        )
+
 
 class LateralContribution(SQLSubModel):
     _sub_classes = [Data]
@@ -511,6 +518,15 @@ class LateralContribution(SQLSubModel):
     def has_reach(self):
         return self._reach is not None
 
+    def cloned_for(self, reach, begin_section, end_section):
+        new = type(self)(name=self._name, status=self._status)
+        new._reach = reach
+        new._begin_section = begin_section
+        new._end_section = end_section
+        new._data = [data.cloned() for data in self.data]
+        new.modified()
+        return new
+
     @property
     def begin_rk(self):
         if self._begin_section is None:

src/Model/LateralContribution/LateralContributionList.py

@@ -1,5 +1,5 @@
 # LateralContributionList.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -71,6 +71,89 @@ class LateralContributionList(PamhyrModelListWithTab):
         self._status.modified()
         return n
 
+    def split_reach(self, reach, profile, reach1, reach2):
+        profiles = reach.reach.profiles
+        split_index = profiles.index(profile)
+
+        parts = [
+            (
+                reach1,
+                0,
+                split_index,
+                dict(zip(
+                    profiles[:split_index + 1],
+                    reach1.reach.profiles
+                ))
+            ),
+            (
+                reach2,
+                split_index,
+                len(profiles) - 1,
+                dict(zip(
+                    profiles[split_index:],
+                    reach2.reach.profiles
+                ))
+            ),
+        ]
+
+        for tab in self._tabs:
+            contributions = [
+                contribution
+                for contribution in self.get_tab(tab)
+                if contribution.reach is reach
+            ]
+
+            for contribution in contributions:
+                if (contribution.begin_section not in profiles or
+                        contribution.end_section not in profiles):
+                    continue
+
+                begin = profiles.index(contribution.begin_section)
+                end = profiles.index(contribution.end_section)
+                lower, upper = sorted((begin, end))
+                reverse = begin > end
+                clones = []
+
+                for new_reach, part_lower, part_upper, sections in parts:
+                    clipped_lower = max(lower, part_lower)
+                    clipped_upper = min(upper, part_upper)
+                    if clipped_lower >= clipped_upper:
+                        continue
+
+                    begin_index = (
+                        clipped_upper if reverse else clipped_lower
+                    )
+                    end_index = (
+                        clipped_lower if reverse else clipped_upper
+                    )
+                    clones.append(contribution.cloned_for(
+                        new_reach,
+                        sections[profiles[begin_index]],
+                        sections[profiles[end_index]]
+                    ))
+
+                if len(clones) == 0:
+                    continue
+
+                self._tabs[tab].extend(clones)
+
+        self._status.modified()
+
+    def get_tab_for_enabled_reaches(self, tab):
+        return [
+            contribution
+            for contribution in self.get_tab(tab)
+            if (contribution.reach is None or
+                (not contribution.reach.is_deleted() and
+                 contribution.reach.is_enable()))
+        ]
+
+    def get_for_enabled_reaches(self, tab, index):
+        contributions = self.get_tab_for_enabled_reaches(tab)
+        if not 0 <= index < len(contributions):
+            return None
+        return contributions[index]
+
     def __copy__(self):
         new = LateralContributionList()
 

src/Model/LateralContribution/LateralContributionTypes.py

@@ -1,5 +1,5 @@
 # LateralContributionTypes.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/LateralContributionsAdisTS/LateralContributionAdisTS.py

@@ -1,5 +1,5 @@
 # LateralContributionAdisTS.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -192,6 +192,13 @@ class Data(SQLSubModel):
     def __setitem__(self, key, value):
         self._data[key] = self._types[key](value)
 
+    def cloned(self):
+        return Data(
+            self[0], self[1],
+            types=self._types,
+            status=self._status
+        )
+
 
 class LateralContributionAdisTS(SQLSubModel):
     _sub_classes = [Data]
@@ -477,6 +484,18 @@ class LateralContributionAdisTS(SQLSubModel):
         self._end_rk = end_rk
         self.modified()
 
+    def cloned_for(self, reach, begin_rk, end_rk):
+        new = LateralContributionAdisTS(
+            pollutant=self._pollutant,
+            status=self._status
+        )
+        new._reach = reach
+        new._begin_rk = begin_rk
+        new._end_rk = end_rk
+        new._data = [data.cloned() for data in self.data]
+        new.modified()
+        return new
+
     @property
     def _default_0(self):
         return self._types[0](0)

src/Model/LateralContributionsAdisTS/LateralContributionsAdisTSList.py

@@ -1,5 +1,5 @@
 # LateralContributionsAdisTSList.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -68,6 +68,46 @@ class LateralContributionsAdisTSList(PamhyrModelList):
         self._status.modified()
         return n
 
+    def split_reach(self, reach, profile, reach1, reach2):
+        parts = []
+        for new_reach in (reach1, reach2):
+            rks = new_reach.reach.get_rk()
+            if len(rks) == 0:
+                continue
+            parts.append((new_reach.id, min(rks), max(rks)))
+
+        contributions = [
+            contribution
+            for contribution in self.lst
+            if contribution.reach == reach.id
+        ]
+        clones = []
+
+        for contribution in contributions:
+            begin = contribution.begin_rk
+            end = contribution.end_rk
+            if begin is None or end is None:
+                continue
+
+            lower, upper = sorted((begin, end))
+            reverse = begin > end
+
+            for new_reach, part_lower, part_upper in parts:
+                clipped_lower = max(lower, part_lower)
+                clipped_upper = min(upper, part_upper)
+                if clipped_lower >= clipped_upper:
+                    continue
+
+                begin_rk = clipped_upper if reverse else clipped_lower
+                end_rk = clipped_lower if reverse else clipped_upper
+                clones.append(contribution.cloned_for(
+                    new_reach, begin_rk, end_rk
+                ))
+
+        if len(clones) != 0:
+            self._lst.extend(clones)
+            self._status.modified()
+
     @property
     def Lat_Cont_List(self):
         return self.lst

src/Model/Network/Edge.py

@@ -1,5 +1,5 @@
 # Edge.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/Network/Graph.py

@@ -1,5 +1,5 @@
 # Graph.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/Network/Node.py

@@ -1,5 +1,5 @@
 # Node.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/Network/Point.py

@@ -1,5 +1,5 @@
 # Point.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/Network/__init__.py

@@ -1,5 +1,5 @@
 # __init__.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/Network/test_network.py

@@ -1,5 +1,5 @@
 # test_Network.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/OutputRKAdists/OutputRKAdists.py

@@ -1,208 +0,0 @@
-# OutputRKAdists.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-# -*- coding: utf-8 -*-
-
-import logging
-
-from tools import (
-    trace, timer,
-    old_pamhyr_date_to_timestamp,
-    date_iso_to_timestamp,
-    date_dmy_to_timestamp,
-)
-
-from Model.Tools.PamhyrDB import SQLSubModel
-from Model.Except import NotImplementedMethodeError
-from Model.Scenario import Scenario
-
-logger = logging.getLogger()
-
-
-class OutputRKAdists(SQLSubModel):
-    _sub_classes = []
-
-    def __init__(self, id: int = -1, reach=None,
-                 rk=None, title: str = "",  status=None,
-                 owner_scenario=-1):
-        super(OutputRKAdists, self).__init__(
-            id=id, status=status,
-            owner_scenario=owner_scenario
-        )
-
-        self._reach = reach
-        self._rk = rk
-        self._title = str(title)
-        self._enabled = True
-
-    @property
-    def reach(self):
-        return self._reach
-
-    @reach.setter
-    def reach(self, reach_id):
-        self._reach = reach_id
-        self._status.modified()
-
-    @property
-    def rk(self):
-        return self._rk
-
-    @rk.setter
-    def rk(self, profile_id):
-        self._rk = profile_id
-        self._status.modified()
-
-    @property
-    def title(self):
-        return self._title
-
-    @title.setter
-    def title(self, title):
-        self._title = title
-        self._status.modified()
-
-    @classmethod
-    def _db_create(cls, execute, ext=""):
-        execute(f"""
-          CREATE TABLE  output_rk_adists{ext}(
-            {cls.create_db_add_pamhyr_id()},
-            deleted BOOLEAN NOT NULL DEFAULT FALSE,
-            reach INTEGER NOT NULL,
-            rk REAL NOT NULL,
-            title TEXT NOT NULL,
-            {Scenario.create_db_add_scenario()},
-            {Scenario.create_db_add_scenario_fk()},
-            FOREIGN KEY(reach) REFERENCES river_reach(id)
-          )
-        """)
-
-        return cls._create_submodel(execute)
-
-    @classmethod
-    def _db_update(cls, execute, version, data=None):
-        major, minor, release = version.strip().split(".")
-
-        if major == "0" and int(minor) < 2:
-            if cls.is_table_exists(execute, "OutputRKAdists"):
-                cls._db_update_to_0_2_0(execute, data)
-            else:
-                cls._db_create(execute)
-
-        return True
-
-    @classmethod
-    def _db_update_to_0_2_0(cls, execute, data):
-        table = "OutputRKAdists"
-        table_new = "output_rk_adists"
-        reachs = data['id2pid']['river_reach']
-
-        cls.update_db_add_pamhyr_id(execute, table, data)
-        Scenario.update_db_add_scenario(execute, table)
-
-        cls._db_create(execute, ext="_tmp")
-
-        execute(
-            f"INSERT INTO {table_new}_tmp " +
-            "(pamhyr_id, reach, rk, title, scenario) " +
-            "SELECT pamhyr_id, reach, rk, title, scenario " +
-            f"FROM {table}"
-        )
-
-        execute(f"DROP TABLE {table}")
-        execute(f"ALTER TABLE {table_new}_tmp RENAME TO {table_new}")
-
-        cls._db_update_to_0_2_0_set_reach_pid(execute, table_new, reachs)
-
-    @classmethod
-    def _db_load(cls, execute, data=None):
-        new = []
-        status = data['status']
-        scenario = data["scenario"]
-        loaded = data['loaded_pid']
-
-        # reach   = data["reach"]
-        # profile = data["profile"]
-
-        if scenario is None:
-            return new
-
-        table = execute(
-            "SELECT pamhyr_id, deleted, reach, rk, title, scenario " +
-            f"FROM  output_rk_adists"
-        )
-
-        if table is not None:
-            for row in table:
-                it = iter(row)
-
-                pid = next(it)
-                deleted = (next(it) == 1)
-                id_reach = next(it)
-                id_rk = next(it)
-                title = next(it)
-                owner_scenario = next(it)
-
-                new_output = cls(
-                    id=pid, reach=id_reach,
-                    rk=id_rk, title=title,
-                    status=status,
-                    owner_scenario=owner_scenario,
-                )
-                if deleted:
-                    new_output.set_as_deleted()
-
-                loaded.add(pid)
-                new.append(new_output)
-
-        data["scenario"] = scenario.parent
-        new += cls._db_load(execute, data)
-        data["scenario"] = scenario
-
-        return new
-
-    def _db_save(self, execute, data=None):
-        if not self.must_be_saved():
-            return True
-
-        execute(
-            "DELETE FROM output_rk_adists " +
-            f"WHERE pamhyr_id = {self.id} " +
-            f"AND scenario = {self._status.scenario_id} "
-        )
-
-        execute(
-            "INSERT INTO " +
-            "output_rk_adists(pamhyr_id, deleted, " +
-            "reach, rk, title, scenario) " +
-            "VALUES (" +
-            f"{self.id}, {self._db_format(self.is_deleted())}, " +
-            f"{self._reach}, {self._rk}, " +
-            f"'{self._db_format(self._title)}', " +
-            f"{self._status.scenario_id}" +
-            ")"
-        )
-
-        return True
-
-    @property
-    def enabled(self):
-        return self._enabled
-
-    @enabled.setter
-    def enabled(self, enabled):
-        self._enabled = enabled
-        self._status.modified()

src/Model/Pollutants/Pollutants.py

@@ -1,5 +1,5 @@
 # Pollutants.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -350,6 +350,7 @@ class Pollutants(SQLSubModel):
           CREATE TABLE pollutants{ext}(
             {cls.create_db_add_pamhyr_id()},
             deleted BOOLEAN NOT NULL DEFAULT FALSE,
+            enabled BOOLEAN NOT NULL DEFAULT TRUE,
             name TEXT NOT NULL,
             {Scenario.create_db_add_scenario()},
             {Scenario.create_db_add_scenario_fk()}
@@ -373,6 +374,14 @@ class Pollutants(SQLSubModel):
                 cls._db_create(execute)
                 created = True
 
+        if major == "0" and minor == "2":
+            if int(release) < 6:
+                execute(f"ALTER TABLE pollutants " +
+                        f"ADD COLUMN enabled BOOLEAN NOT NULL DEFAULT TRUE")
+
+                # cls._db_update_to_0_2_5(execute, data)
+                # # created = True
+
         if not created:
             return cls._update_submodel(execute, version, data)
 
@@ -410,7 +419,8 @@ class Pollutants(SQLSubModel):
             return new
 
         table = execute(
-            "SELECT pamhyr_id, deleted, name, scenario FROM pollutants " +
+            "SELECT pamhyr_id, deleted, enabled, name, scenario " +
+            "FROM pollutants " +
             f"WHERE scenario = {scenario.id} " +
             f"AND pamhyr_id NOT IN ({', '.join(map(str, loaded))})"
         )
@@ -421,6 +431,7 @@ class Pollutants(SQLSubModel):
 
                 pid = next(it)
                 deleted = (next(it) == 1)
+                enabled = (next(it) == 1)
                 name = next(it)
                 owner_scenario = next(it)
 
@@ -431,6 +442,8 @@ class Pollutants(SQLSubModel):
                 )
                 if deleted:
                     new_pollutant.set_as_deleted()
+                if not enabled:
+                    new_pollutant.enabled = False
 
                 data["pollutant"] = new_pollutant
                 new_pollutant._data = PollutantCharacteristics._db_load(
@@ -472,9 +485,10 @@ class Pollutants(SQLSubModel):
 
         execute(
             "INSERT INTO " +
-            "pollutants(pamhyr_id, deleted, name, scenario) " +
+            "pollutants(pamhyr_id, deleted, enabled, name, scenario) " +
             "VALUES (" +
             f"{self.id}, {self._db_format(self.is_deleted())}, " +
+            f"{self._db_format(self._enabled)}, " +
             f"'{self._db_format(self._name)}', " +
             f"{self._status.scenario_id}" +
             ")"

src/Model/Reservoir/Reservoir.py

@@ -1,5 +1,5 @@
 # Reservoir.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/Reservoir/ReservoirList.py

@@ -1,5 +1,5 @@
 # ReservoirList.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/Results/Results.py

@@ -1,5 +1,5 @@
 # Results.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -22,6 +22,8 @@ import numpy as np
 from copy import deepcopy
 from datetime import datetime
 
+from tools import timer
+
 from Model.Scenario import Scenario
 from Model.Tools.PamhyrDB import SQLSubModel
 from Model.Results.River.River import River
@@ -155,8 +157,180 @@ class AdditionalData(SQLSubModel):
         return True
 
 
+class TableData(SQLSubModel):
+    _sub_classes = []
+
+    def __init__(self, id=-1, study=None,
+                 legend="", data=None,
+                 owner_scenario=-1):
+        super(TableData, self).__init__(
+            id=id, status=study.status,
+            owner_scenario=owner_scenario
+        )
+
+        self._study = study
+        self._legend = legend
+        self._data = data
+
+    @property
+    def data(self):
+        return self._data
+
+    @classmethod
+    def _db_create(cls, execute, ext=""):
+        execute(f"""
+          CREATE TABLE results_table_data{ext} (
+            {cls.create_db_add_pamhyr_id()},
+            result INTEGER NOT NULL,
+            legend TEXT NOT NULL,
+            unit TEXT NOT NULL,
+            data_shape_x INTEGER NOT NULL,
+            data_shape_y INTEGER NOT NULL,
+            data_shape_z INTEGER DEFAULT -1,
+            data BLOB NOT NULL,
+            {Scenario.create_db_add_scenario()},
+            {Scenario.create_db_add_scenario_fk()},
+            FOREIGN KEY(result) REFERENCES results(pamhyr_id),
+            PRIMARY KEY(pamhyr_id, result, legend, scenario)
+          )
+        """)
+
+        if ext != "":
+            return True
+
+        return cls._create_submodel(execute)
+
+    @classmethod
+    def _db_update(cls, execute, version, data=None):
+        if not cls.is_table_exists(execute, "results_table_data"):
+            cls._db_create(execute)
+
+        return cls._update_submodel(execute, version, data)
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        res = {}
+
+        study = data['study']
+        status = data['status']
+        scenario = data["scenario"]
+        result = data["result"]
+        rid = data["result_pid"]
+
+        table = execute(
+            "SELECT pamhyr_id, " +
+            "legend, unit, " +
+            "data_shape_x, data_shape_y, data_shape_z, " +
+            "data, " +
+            "scenario " +
+            "FROM results_table_data " +
+            f"WHERE scenario = {scenario.id} " +
+            f"AND result = {rid}"
+        )
+
+        for v in table:
+            it = iter(v)
+
+            pid = next(it)
+            legend = next(it)
+            unit = next(it)
+            data_shape_x = next(it)
+            data_shape_y = next(it)
+            data_shape_z = next(it)
+            data = next(it)
+            owner_scenario = next(it)
+
+            dtype = cls._unit_to_dtype(unit)
+
+            np_data = np.frombuffer(data, dtype=dtype)
+            if data_shape_y == -1:
+                np_data = np.reshape(np_data, data_shape_x)
+            elif data_shape_z == -1:
+                np_data = np.reshape(np_data, (data_shape_x,
+                                               data_shape_y))
+            else:
+                np_data = np.reshape(np_data, (data_shape_x,
+                                               data_shape_y,
+                                               data_shape_z))
+
+            new_table = cls(study=study,
+                            legend=legend, data=np_data,
+                            owner_scenario=owner_scenario)
+
+            res[legend] = new_table
+
+        return res
+
+    def _db_save(self, execute, data=None):
+        if self._status.scenario.id != self._owner_scenario:
+            return
+
+        shape_x = -1
+        shape_y = -1
+        shape_z = -1
+        shape = self._data.shape
+
+        if len(shape) == 2:
+            shape_x, shape_y = shape
+        elif len(shape == 1):
+            shape_x, = shape
+        elif len(shape == 3):
+            shape_x, shape_y, shape_z = shape
+        else:
+            logger.error(
+                f"Failed to parse numpy shape: {shape}"
+            )
+
+        execute(
+            "INSERT INTO " +
+            "results_table_data (pamhyr_id, result, " +
+            "legend, unit, " +
+            "data_shape_x, data_shape_y, data_shape_z, " +
+            "data, " +
+            "scenario) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+            self._pamhyr_id, data["result"],
+            self._legend, self._dtype_to_unit(self._data.dtype),
+            shape_x, shape_y, shape_z,
+            self._data,
+            self._owner_scenario
+        )
+
+        return True
+
+    @classmethod
+    def _unit_to_dtype(cls, unit):
+        t = {
+            "i32": np.int32, "i64": np.int64,
+            "u32": np.uint32, "u64": np.uint64,
+            "f32": np.float32, "f64": np.float64,
+        }
+
+        return t[unit]
+
+    def _dtype_to_unit(self, dtype):
+        t = {
+            np.dtype(np.int32): "i32", np.dtype(np.int64): "i64",
+            np.dtype(np.uint32): "u32", np.dtype(np.uint64): "u64",
+            np.dtype(np.float32): "f32", np.dtype(np.float64): "f64",
+        }
+
+        return t[dtype]
+
+    def table(self):
+        return self._data
+
+    def __len__(self):
+        return len(self._data)
+
+    def __getitem__(self, key):
+        if isinstance(key, tuple):
+            return self._data[key[0], key[1]]
+
+        self._date[key]
+
+
 class Results(SQLSubModel):
-    _sub_classes = [River, AdditionalData]
+    _sub_classes = [River, TableData, AdditionalData]
 
     def __init__(self, id=-1, study=None, solver=None,
                  repertory="", name="0"):
@@ -167,7 +341,7 @@ class Results(SQLSubModel):
 
         self._name = name
         self._study = study
-        self._river = River(self._study)
+        self._river = River(self._study, self)
 
         self._solver = solver
         self._repertory = repertory
@@ -177,8 +351,11 @@ class Results(SQLSubModel):
             "creation_date": datetime.now(),
             "study_revision": study.status.version,
             "additional_data": [],
+            "table": {},
         }
 
+        self._ts_index = {}
+
         if solver is not None:
             self.set("solver_type", solver._type)
 
@@ -195,6 +372,7 @@ class Results(SQLSubModel):
     def study(self):
         return self._study
 
+    @timer
     def set(self, key, value):
         self._meta_data[key] = value
 
@@ -212,6 +390,16 @@ class Results(SQLSubModel):
     def get(self, key):
         return self._meta_data[key]
 
+    def set_timestamp_index(self, index):
+        self._ts_index = index
+
+    def get_timestamp_id(self, ts):
+        return self._ts_index[ts]
+
+    def compute_timestamp_index(self):
+        for i, ts in enumerate(self._meta_data["timestamps"]):
+            self._ts_index[ts] = i
+
     def reload(self):
         return self._solver.results(
             self._study,
@@ -309,11 +497,20 @@ class Results(SQLSubModel):
             new_results.set("study_revision", revision)
             new_results.set("creation_date", creation_date)
 
+            data["result_pid"] = pid
+            data["result"] = new_results
+
+            table_data = TableData._db_load(execute, data)
+            new_results.set("table", table_data)
+
             sf = ">" + ''.join(itertools.repeat("d", nb_timestamps))
             ts = struct.unpack(sf, timestamps_bytes)
             new_results.set("timestamps", ts)
 
             data["timestamps"] = sorted(ts)
+            new_results.compute_timestamp_index()
+
+            data["parent"] = new_results
             new_results._river = River._db_load(execute, data)
 
             new_results.set(
@@ -321,6 +518,20 @@ class Results(SQLSubModel):
                 AdditionalData._db_load(execute, data)
             )
 
+            # Update global index
+            i = 0
+            for reach in new_results._river.reachs:
+                nb = len(reach.profiles)
+                reach.set_global_index(range(i, i + nb))
+                i += nb
+
+            if "Z" in table_data:
+                for ts in data["timestamps"]:
+                    new_results._river.update_water_limits(
+                        ts,
+                        table_data["Z"][new_results.get_timestamp_id(ts), :]
+                    )
+
             yield (solver_type, new_results)
 
     def _db_save_clear(self, execute, solver_type, data=None):
@@ -343,6 +554,11 @@ class Results(SQLSubModel):
                     f"WHERE scenario = {self._owner_scenario} " +
                     f"AND result = {pid}"
                 )
+                execute(
+                    "DELETE FROM results_table_data " +
+                    f"WHERE scenario = {self._owner_scenario} " +
+                    f"AND result = {pid}"
+                )
                 execute(
                     "DELETE FROM results_add_data " +
                     f"WHERE scenario = {self._owner_scenario} " +
@@ -386,7 +602,19 @@ class Results(SQLSubModel):
         data["result"] = self._pamhyr_id
         self._river._db_save(execute, data)
 
+        tables = self.get("table")
+        for legend in tables:
+            tables[legend]._db_save(execute, data)
+
         for add_data in self.get("additional_data"):
             add_data._db_save(execute, data)
 
         return True
+
+    def new_table_data(self, legend, data):
+        return TableData(
+            study=self._study,
+            legend=legend,
+            data=data,
+            owner_scenario=self._owner_scenario
+        )

src/Model/Results/ResultsAdisTS.py

@@ -1,5 +1,5 @@
 # Results.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/Results/River/River.py

@@ -1,5 +1,5 @@
 # River.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -14,12 +14,13 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+import types
 import struct
 import logging
 import itertools
 import numpy as np
 
-from tools import flatten
+from tools import flatten, timer
 from functools import reduce
 from datetime import datetime
 
@@ -30,15 +31,17 @@ logger = logging.getLogger()
 
 
 class Profile(SQLSubModel):
-    def __init__(self, profile, study):
+    def __init__(self, profile, study, parent):
         super(Profile, self).__init__(
             id=-1, status=study.status,
             owner_scenario=study.status.scenario.id
         )
 
+        self._parent = parent
         self._study = study
         self._profile = profile  # Source profile in the study
         self._data = {}  # Dict of dict {<ts>: {<key>: <value>, ...}, ...}
+        self._global_index = -1
 
     def __len__(self):
         return len(self._data)
@@ -55,15 +58,26 @@ class Profile(SQLSubModel):
     def geometry(self):
         return self._profile
 
+    @property
+    def global_index(self):
+        return self._global_index
+
+    @global_index.setter
+    def global_index(self, id):
+        self._global_index = id
+
+    @timer
     def set(self, timestamp, key, data):
         if timestamp not in self._data:
             self._data[timestamp] = {}
 
         self._data[timestamp][key] = data
 
+    @timer
     def get_ts(self, timestamp):
         return self._data[timestamp]
 
+    @timer
     def get_key(self, key):
         res = list(
             map(lambda ts: self._data[ts][key],
@@ -71,17 +85,26 @@ class Profile(SQLSubModel):
         )
         return res
 
+    @timer
     def get_ts_key(self, timestamp, key):
         if timestamp in self._data:
             if key in self._data[timestamp]:
-                return self._data[timestamp][key]
+                v = self._data[timestamp][key]
+
+                # If is a generator, compute value(s)
+                if isinstance(v, types.GeneratorType):
+                    v = next(v)
+                    self._data[timestamp][key] = v
+
+                return v
+
         return None
 
     def has_sediment_layers(self):
         return any(map(lambda ts: "sl" in self._data[ts], self._data))
 
     def has_bedload(self):
-        return any(map(lambda ts: "zfd" in self._data[ts], self._data))
+        return any(map(lambda ts: "sl" in self._data[ts], self._data))
 
     @classmethod
     def _db_create(cls, execute, ext=""):
@@ -114,9 +137,9 @@ class Profile(SQLSubModel):
 
     @classmethod
     def _db_load(cls, execute, data=None):
-        new = {}
         status = data['status']
 
+        parent = data['parent']
         study = data['study']
         reach = data['reach']
         profile = data['profile']
@@ -124,11 +147,14 @@ class Profile(SQLSubModel):
         loaded = data['loaded_pid']
         timestamps = data['timestamps']
 
+        new = cls(profile, study, parent)
+
         values = execute(
             "SELECT pamhyr_id, result, key, " +
             "len_data, data, scenario " +
             "FROM results_data " +
             f"WHERE scenario = {scenario.id} " +
+            f"AND result = {data['result_pid']} " +
             f"AND reach = {reach.pamhyr_id} " +
             f"AND section = {profile.pamhyr_id}"
         )
@@ -143,12 +169,6 @@ class Profile(SQLSubModel):
             data = next(it)
             owner_scenario = next(it)
 
-            if profile not in new:
-                new_data = cls(profile, study)
-                new[profile] = new_data
-            else:
-                new_data = new[profile]
-
             if key in ["Z", "Q", "V"]:
                 sf = ">" + ''.join(itertools.repeat("f", len_data))
                 len_values = len(values)
@@ -161,11 +181,11 @@ class Profile(SQLSubModel):
                 )
 
             for timestamp, value in zip(timestamps, values):
-                new_data.set(timestamp, key, value)
+                new.set(timestamp, key, value)
                 if key == "Z":
-                    new_data.update_water_limits(timestamp, value)
+                    new.update_water_limits(timestamp, value)
 
-        return list(new.values())
+        return new
 
     @classmethod
     def _db_load_data_sl_format(cls, values, len_data, timestamps):
@@ -257,20 +277,23 @@ class Profile(SQLSubModel):
 class Reach(SQLSubModel):
     _sub_classes = [Profile]
 
-    def __init__(self, reach, study, with_init=True):
+    def __init__(self, reach, study, parent, with_init=True, profiles=None):
         super(Reach, self).__init__(
             id=-1, status=study.status,
             owner_scenario=study.status.scenario.id
         )
 
+        self._parent = parent
         self._study = study
         self._reach = reach  # Source reach in the study
         self._profiles = []
         if with_init:
+            if profiles is None:
+                profiles = reach.profiles
             self._profiles = list(
                 map(
-                    lambda p: Profile(p, self._study),
+                    lambda p: Profile(p, self._study, self._parent),
-                    reach.profiles
+                    profiles
                 )
             )
 
@@ -279,6 +302,9 @@ class Reach(SQLSubModel):
                 lambda p: p.name[0:8] != 'interpol', self._profiles
             )
         )
+
+        self._global_index = (-1, -1)
+
         self._buffers = {}
 
     def __len__(self):
@@ -307,6 +333,17 @@ class Reach(SQLSubModel):
     def profile(self, id):
         return self._profiles[id]
 
+    def set_global_index(self, indexs):
+        self._global_index = (indexs[0], indexs[-1])
+
+        for profile, ind in zip(self._profiles, indexs):
+            profile.global_index = ind
+
+    @property
+    def global_index(self):
+        return self._global_index
+
+    @timer
     def set(self, profile_id, timestamp, key, data):
         self._profiles[profile_id].set(timestamp, key, data)
 
@@ -322,6 +359,10 @@ class Reach(SQLSubModel):
         for i, p in enumerate(self._profiles):
             self._buffers[key][:, i] = p.get_key(key)
 
+    def update_water_limits(self, timestamp, z_data):
+        for profile, z in zip(self._profiles, z_data):
+            profile.update_water_limits(timestamp, z)
+
     @classmethod
     def _db_create(cls, execute, ext=""):
         return cls._create_submodel(execute)
@@ -335,12 +376,20 @@ class Reach(SQLSubModel):
         reach = data["reach"]
 
         new_reach = cls(
-            data["reach"], data["study"], with_init=False
+            data["reach"], data["study"], data["parent"],
+            with_init=False
         )
 
         for i, profile in enumerate(reach.profiles):
             data["profile"] = profile
-            new_reach._profiles += Profile._db_load(execute, data)
+            result_profile = Profile._db_load(execute, data)
+            if len(result_profile) > 0:
+                new_reach._profiles.append(result_profile)
+
+        new_reach._profile_mask = [
+            profile.name[0:8] != 'interpol'
+            for profile in new_reach._profiles
+        ]
 
         return new_reach
 
@@ -354,13 +403,14 @@ class Reach(SQLSubModel):
 class River(SQLSubModel):
     _sub_classes = [Reach]
 
-    def __init__(self, study):
+    def __init__(self, study, parent):
         super(River, self).__init__(
             id=-1, status=study.status,
             owner_scenario=study.status.scenario.id
         )
 
         self._study = study
+        self._parent = parent
 
         # Dict with timestamps as key
         self._reachs = []
@@ -378,10 +428,13 @@ class River(SQLSubModel):
     def has_reach(self, id):
         return 0 <= id < len(self._reachs)
 
-    def add(self, reach_id):
+    def add(self, reach_id, profiles=None):
         reachs = self._study.river.enable_edges()
 
-        new = Reach(reachs[reach_id].reach, self._study)
+        new = Reach(
+            reachs[reach_id].reach, self._study, self._parent,
+            profiles=profiles
+        )
 
         self._reachs.append(new)
         return new
@@ -394,6 +447,15 @@ class River(SQLSubModel):
             )
         )
 
+    def update_water_limits(self, timestamp, data):
+        for reach in self._reachs:
+            ind = reach.global_index
+
+            reach.update_water_limits(
+                timestamp,
+                data[ind[0]:ind[1]]
+            )
+
     @classmethod
     def _db_create(cls, execute, ext=""):
         return cls._create_submodel(execute)
@@ -405,13 +467,15 @@ class River(SQLSubModel):
     @classmethod
     def _db_load(cls, execute, data=None):
         study = data["study"]
-        new_river = cls(study)
+        parent = data["parent"]
+
+        new_river = cls(study, parent)
 
         for reach in study.river.reachs():
             data["reach"] = reach.reach
-            new_river._reachs.append(
+            result_reach = Reach._db_load(execute, data)
-                Reach._db_load(execute, data)
+            if len(result_reach) > 0:
-            )
+                new_river._reachs.append(result_reach)
 
         return new_river
 

src/Model/Results/River/RiverAdisTS.py

@@ -1,5 +1,5 @@
 # River.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -64,13 +64,15 @@ class Profile(object):
 
 
 class Reach(object):
-    def __init__(self, reach, study):
+    def __init__(self, reach, study, profiles=None):
         self._study = study
         self._reach = reach  # Source reach in the study
+        if profiles is None:
+            profiles = reach.profiles
         self._profiles = list(
             map(
                 lambda p: Profile(p, self._study),
-                reach.profiles
+                profiles
             )
         )
 
@@ -89,6 +91,10 @@ class Reach(object):
     def profiles(self):
         return self._profiles.copy()
 
+    def get_rk(self):
+        """Return the PK values for profiles present in the results."""
+        return [profile.rk for profile in self._profiles]
+
     def profile(self, id):
         return self._profiles[id]
 
@@ -119,10 +125,10 @@ class River(object):
     def has_reach(self, id):
         return 0 <= id < len(self._reachs)
 
-    def add(self, reach_id):
+    def add(self, reach_id, profiles=None):
         reachs = self._study.river.enable_edges()
 
-        new = Reach(reachs[reach_id].reach, self._study)
+        new = Reach(reachs[reach_id].reach, self._study, profiles=profiles)
 
         self._reachs.append(new)
         return new

src/Model/River.py

@@ -1,5 +1,5 @@
 # River.py -- Pamhyr river model
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -49,7 +49,6 @@ from Model.REPLine.REPLineList import REPLineList
 
 from Solver.Solvers import solver_type_list
 
-from Model.OutputRKAdists.OutputRKListAdists import OutputRKAdistsList
 from Model.Pollutants.PollutantsList import PollutantsList
 from Model.InitialConditionsAdisTS.InitialConditionsAdisTSList \
     import InitialConditionsAdisTSList
@@ -59,6 +58,16 @@ from Model.LateralContributionsAdisTS.LateralContributionsAdisTSList \
     import LateralContributionsAdisTSList
 from Model.D90AdisTS.D90AdisTSList import D90AdisTSList
 from Model.DIFAdisTS.DIFAdisTSList import DIFAdisTSList
+
+from Model.InitialConditionsTemperature.InitialConditionsTemperatureList \
+    import InitialConditionsTemperatureList
+
+from Model.BoundaryConditionsTemperature.BoundaryConditionsTemperatureList \
+    import BoundaryConditionsTemperatureList
+
+from Model.WeatherParameters.WeatherParametersList \
+    import WeatherParametersList
+
 from Model.GeoTIFF.GeoTIFFList import GeoTIFFList
 from Model.Results.Results import Results
 
@@ -468,13 +477,15 @@ class River(Graph):
         HydraulicStructureList,
         AddFileList,
         REPLineList,
-        OutputRKAdistsList,
         PollutantsList,
         InitialConditionsAdisTSList,
         BoundaryConditionsAdisTSList,
         LateralContributionsAdisTSList,
         D90AdisTSList,
         DIFAdisTSList,
+        InitialConditionsTemperatureList,
+        BoundaryConditionsTemperatureList,
+        WeatherParametersList,
         GeoTIFFList,
         Results
     ]
@@ -502,7 +513,6 @@ class River(Graph):
         )
         self._additional_files = AddFileList(status=self._status)
         self._rep_lines = REPLineList(status=self._status)
-        self._Output_rk_adists = OutputRKAdistsList(status=self._status)
         self._Pollutants = PollutantsList(status=self._status)
         self._InitialConditionsAdisTS = InitialConditionsAdisTSList(
             status=self._status)
@@ -512,6 +522,13 @@ class River(Graph):
             status=self._status)
         self._D90AdisTS = D90AdisTSList(status=self._status)
         self._DIFAdisTS = DIFAdisTSList(status=self._status)
+        self._InitialConditionsTemperature = (
+            InitialConditionsTemperatureList(status=self._status)
+        )
+        self._BoundaryConditionsTemperature = (
+            BoundaryConditionsTemperatureList(status=self._status)
+        )
+        self._WeatherParameters = (WeatherParametersList(status=self._status))
 
         self._geotiff = GeoTIFFList(status=self._status)
 
@@ -610,10 +627,6 @@ class River(Graph):
 
         new._Pollutants = PollutantsList._db_load(execute, data)
 
-        new._Output_rk_adists = OutputRKAdistsList._db_load(
-            execute, data
-        )
-
         new._InitialConditionsAdisTS = InitialConditionsAdisTSList._db_load(
             execute, data)
 
@@ -627,6 +640,14 @@ class River(Graph):
 
         new._DIFAdisTS = DIFAdisTSList._db_load(execute, data)
 
+        new._InitialConditionsTemperature = \
+            InitialConditionsTemperatureList._db_load(execute, data)
+
+        new._BoundaryConditionsTemperature = \
+            BoundaryConditionsTemperatureList._db_load(execute, data)
+
+        new._WeatherParameters = WeatherParametersList._db_load(execute, data)
+
         new._geotiff = GeoTIFFList._db_load(execute, data)
 
         return new
@@ -654,7 +675,6 @@ class River(Graph):
         for solver in self._parameters:
             objs.append(self._parameters[solver])
 
-        objs.append(self._Output_rk_adists)
         objs.append(self._Pollutants)
         objs.append(self._InitialConditionsAdisTS)
         objs.append(self._BoundaryConditionsAdisTS)
@@ -662,6 +682,10 @@ class River(Graph):
         objs.append(self._D90AdisTS)
         objs.append(self._DIFAdisTS)
 
+        objs.append(self._InitialConditionsTemperature)
+        objs.append(self._BoundaryConditionsTemperature)
+        objs.append(self._WeatherParameters)
+
         objs.append(self._geotiff)
 
         for solv_type in self.results:
@@ -734,12 +758,14 @@ class River(Graph):
             self._hydraulic_structures,
             self._additional_files,
             self._rep_lines,
-            self._Output_rk_adists,
             self._Pollutants,
             self._InitialConditionsAdisTS,
             self._BoundaryConditionsAdisTS,
             self._LateralContributionsAdisTS,
             self._D90AdisTS, self._DIFAdisTS,
+            self._InitialConditionsTemperature,
+            self._BoundaryConditionsTemperature,
+            self._WeatherParameters,
             self._geotiff,
         ]
 
@@ -845,10 +871,6 @@ Last export at: @date."""
     def parameters(self):
         return self._parameters
 
-    @property
-    def Output_rk_adists(self):
-        return self._Output_rk_adists
-
     @property
     def Pollutants(self):
         return self._Pollutants
@@ -873,6 +895,67 @@ Last export at: @date."""
     def dif_adists(self):
         return self._DIFAdisTS
 
+    @property
+    def ic_temperature(self):
+        return self._InitialConditionsTemperature
+
+    @property
+    def boundary_conditions_temperature(self):
+        return self._BoundaryConditionsTemperature
+
+    @property
+    def weather_parameters(self):
+        return self._WeatherParameters
+
+    def profile_dependencies(self, profile):
+        """Return model data which directly reference *profile*.
+
+        PK-based intervals are deliberately not included: only explicit
+        references to the profile object prevent it from being disabled.
+        """
+        dependencies = []
+
+        def add(kind, item, association):
+            dependencies.append({
+                "kind": kind,
+                "item": item,
+                "association": association,
+            })
+
+        for structure in self._hydraulic_structures.lst:
+            if structure.input_section is profile:
+                add("hydraulic_structure", structure, "")
+
+        for tab in self._lateral_contribution._tabs_list:
+            for contribution in self._lateral_contribution.get_tab(tab):
+                if contribution.begin_section is profile:
+                    add("lateral_contribution", contribution, "begin_section")
+                if contribution.end_section is profile:
+                    add("lateral_contribution", contribution, "end_section")
+
+        for parameter in self._WeatherParameters.lst:
+            if parameter.begin_section is profile:
+                add("weather_parameter", parameter, "begin_section")
+            if parameter.end_section is profile:
+                add("weather_parameter", parameter, "end_section")
+
+        reach_id = profile.reach.pamhyr_id
+        for initial_condition in self._InitialConditionsTemperature.lst:
+            for specification in initial_condition.data:
+                same_reach = specification.reach == reach_id
+                same_rk = (
+                    specification.start_rk == profile.rk or
+                    specification.end_rk == profile.rk
+                )
+                if same_reach and same_rk:
+                    add(
+                        "initial_condition_temperature",
+                        specification,
+                        "cross_section_pk",
+                    )
+
+        return dependencies
+
     def get_params(self, solver):
         if solver in self._parameters:
             return self._parameters[solver]
@@ -929,6 +1012,12 @@ Last export at: @date."""
         self._results[solv_type] = results
 
     def _split_reach(self, reach, profile):
+        profiles = reach.reach.profiles
+        if not profiles or profile not in profiles[1:-1]:
+            raise ValueError(
+                "A reach cannot be split at its first or last profile"
+            )
+
         node1 = reach.node1
         node2 = reach.node2
 
@@ -945,4 +1034,32 @@ Last export at: @date."""
         self._add_edge(r1)
         self._add_edge(r2)
 
+        self._initial_conditions.split_reach(
+            reach, profile, r1, r2
+        )
+        self._lateral_contribution.split_reach(
+            reach, profile, r1, r2
+        )
+        self._hydraulic_structures.split_reach(
+            reach, profile, r1, r2
+        )
+        self._InitialConditionsAdisTS.split_reach(
+            reach, profile, r1, r2
+        )
+        self._LateralContributionsAdisTS.split_reach(
+            reach, profile, r1, r2
+        )
+        self._InitialConditionsTemperature.split_reach(
+            reach, profile, r1, r2
+        )
+        self._WeatherParameters.split_reach(
+            reach, profile, r1, r2
+        )
+        self._D90AdisTS.split_reach(
+            reach, profile, r1, r2
+        )
+        self._DIFAdisTS.split_reach(
+            reach, profile, r1, r2
+        )
+
         return r1, r2

src/Model/Scenario.py

@@ -32,7 +32,6 @@ class Scenario(SQLSubModel):
 
     tables_with_deleted_column = [
         # Adists
-        "output_rk_adists",
         "boundary_condition_adists", "boundary_condition_data_adists",
         "lateral_contribution_adists", "lateral_contribution_data_adists",
         "initial_conditions_adists", "initial_conditions_adists_spec",
@@ -53,6 +52,12 @@ class Scenario(SQLSubModel):
         "geometry_pointXYZ", "geometry_profileXYZ",
         "river_reach", "river_node",
         "geotiff", "reservoir", "reservoir_data",
+        # Temperature
+        "boundary_condition_temperature",
+        "boundary_condition_data_temperature",
+        "initial_conditions_temperature",
+        "initial_conditions_temperature_spec",
+        "weather_parameters", "weather_parameters_data",
     ]
 
     related_tables = tables_with_deleted_column + [
@@ -346,11 +351,8 @@ class Scenario(SQLSubModel):
         return None
 
     def workdir(self):
-        srep = ""
+        current = "scenario_" + str(self.id)
-        if self.id != 0:
+        if self.parent is None or self.parent.id == 0:
-            srep = os.path.join(
+            return current
-                self.parent.workdir(),
-                "scenario_" + str(self.id)
-            )
 
-        return srep
+        return os.path.join(self.parent.workdir(), current)

src/Model/Serializable.py

@@ -1,5 +1,5 @@
 # Serializable.py -- Pamhyr pickle abstract class
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/SolverParameters/SolverParametersList.py

@@ -1,5 +1,5 @@
 # SolverParametersList.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -216,6 +216,9 @@ class Parameter(SQLSubModel):
         return new
 
     def _db_save(self, execute, data=None):
+        if not self.must_be_saved():
+            return True
+
         ind = data["ind"]
         solver = data["solver"]
 

src/Model/Status.py

@@ -1,5 +1,5 @@
 # Status.py -- Pamhyr model status class
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/Stricklers/Stricklers.py

@@ -1,5 +1,5 @@
 # Stricklers.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/Stricklers/StricklersList.py

@@ -1,5 +1,5 @@
 # StricklersList.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -60,9 +60,12 @@ class StricklersList(PamhyrModelList):
         return self.lst
 
     def new(self, index):
+        owner_scenario = (
+            self._status.scenario_id if self._status is not None else -1
+        )
         s = Stricklers(
             status=self._status,
-            owner_scenario=self._status.scenario_id
+            owner_scenario=owner_scenario
         )
         self.insert(index, s)
         self.modified()

src/Model/Study.py

@@ -1,5 +1,5 @@
 # Study.py -- Pamhyr Study class
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -21,7 +21,7 @@ import shutil
 import logging
 from datetime import datetime
 
-from tools import timer, timestamp
+from tools import timer, timestamp, parse_datetime
 from functools import reduce
 
 from Model.Tools.PamhyrListExt import PamhyrModelList
@@ -32,6 +32,7 @@ from Model.Scenario import Scenario
 from Model.Status import StudyStatus
 from Model.Except import NotImplementedMethodeError
 from Model.River import River
+from Model.TimeShift import shift_river_times, shift_database_times
 from Model.Geometry.Reach import Reach
 from Model.HydraulicStructures.HydraulicStructures import (
     HydraulicStructure
@@ -46,7 +47,7 @@ logger = logging.getLogger()
 
 
 class Study(SQLModel):
-    _version = "0.2.5"
+    _version = "0.2.10"
 
     _sub_classes = [
         Scenario,
@@ -72,6 +73,7 @@ class Study(SQLModel):
         self.description = ""
         # Time system
         self._time_system = "time"
+        self._pending_time_offset = 0.0
         self._date = datetime.fromtimestamp(0)
 
         if init_new:
@@ -198,6 +200,16 @@ class Study(SQLModel):
         self._date = date
         self.status.modified()
 
+    def change_start_date(self, date, preserve_dates=False):
+        """Change the origin, optionally preserving series calendar dates."""
+        new_date = parse_datetime(date)
+        offset = (parse_datetime(self.date) - new_date).total_seconds()
+        if preserve_dates and offset:
+            shift_river_times(self.river, offset)
+            self._pending_time_offset += offset
+            self._river_scenario_cache.clear()
+        self.use_date(new_date)
+
     @property
     def date(self):
         return self._date
@@ -217,8 +229,7 @@ class Study(SQLModel):
         me.name = name
         me.description = description
         if date is not None:
-            me.use_date()
+            me.use_date(date)
-            me.date = date
         return me
 
     @classmethod
@@ -290,7 +301,14 @@ class Study(SQLModel):
         if major == "0" and int(minor) < 2:
             self._add_into_info_if_not_exists('current_scenario', '0')
 
-        if major == "0" and int(minor) < 2:
+        needs_foreign_keys_disabled = (
+            major == "0" and (
+                int(minor) < 2 or
+                (minor == "2" and int(release) < 10)
+            )
+        )
+
+        if needs_foreign_keys_disabled:
             # Need to temporary disable the sqlite foreign keys
             # checking to update db dans change the table id fk to
             # table pamhyr_id fk
@@ -300,7 +318,7 @@ class Study(SQLModel):
 
         ok = self._update_submodel(version[0], data={})
 
-        if major == "0" and int(minor) < 2:
+        if needs_foreign_keys_disabled:
             # Reactivate foreign keys checking
             self.execute(
                 "PRAGMA foreign_keys = ON;"
@@ -454,6 +472,17 @@ class Study(SQLModel):
         )
         progress()
 
+        if self._pending_time_offset:
+            self._db.execute('SAVEPOINT shift_time_origin')
+            try:
+                shift_database_times(self._db, self._pending_time_offset)
+                self._db.execute('RELEASE SAVEPOINT shift_time_origin')
+            except Exception:
+                self._db.execute('ROLLBACK TO SAVEPOINT shift_time_origin')
+                self._db.execute('RELEASE SAVEPOINT shift_time_origin')
+                raise
+            self._pending_time_offset = 0.0
+
         self._save_submodel(
             [self.scenarios, self._river],
             data=progress
@@ -588,6 +617,9 @@ class Study(SQLModel):
             self.status.stop_loading()
             self.status.scenario = old_scenario
 
+        if self._pending_time_offset:
+            shift_river_times(river, self._pending_time_offset)
+
         # FIXME: Disable scenario cache to save memory usage
         # self._river_scenario_cache[scenario] = river
 

src/Model/TimeShift.py

@@ -0,0 +1,82 @@
+"""Shift temporal series when preserving calendar dates across a new origin."""
+from Model.BoundaryCondition.BoundaryCondition import BoundaryCondition
+from Model.LateralContribution.LateralContribution import LateralContribution
+from Model.WeatherParameters.WeatherParameters import WeatherParameters
+from Model.BoundaryConditionsAdisTS.BoundaryConditionAdisTS import (
+    BoundaryConditionAdisTS
+)
+from Model.LateralContributionsAdisTS.LateralContributionAdisTS import (
+    LateralContributionAdisTS
+)
+from Model.BoundaryConditionsTemperature.BoundaryConditionTemperature import (
+    BoundaryConditionTemperature
+)
+
+
+def shift_river_times(river, offset):
+    changes = []
+    seen = set()
+
+    def collect(obj, data):
+        temporal = isinstance(obj, (
+            BoundaryConditionAdisTS,
+            LateralContributionAdisTS,
+            BoundaryConditionTemperature
+        ))
+        if isinstance(obj, (
+            BoundaryCondition, LateralContribution, WeatherParameters
+        )):
+            temporal = bool(obj.header) and obj.header[0] == 'time'
+        if temporal:
+            for point in obj._data:
+                if id(point) not in seen:
+                    changes.append((point, float(point[0]) + offset))
+                    seen.add(id(point))
+
+    river._data_traversal(modifier=collect)
+    for point, value in changes:
+        # This is a global change of origin, not a scenario-specific edit.
+        point[0] = value
+
+
+def shift_database_times(connection, offset):
+    tables = [
+        (
+            'boundary_condition_data', 'boundary_condition',
+            'bc', BoundaryCondition
+        ),
+        (
+            'lateral_contribution_data', 'lateral_contribution',
+            'lc', LateralContribution
+        ),
+        (
+            'weather_parameters_data', 'weather_parameters',
+            'wp', WeatherParameters
+        ),
+        ('boundary_condition_data_adists', None, None, None),
+        ('lateral_contribution_data_adists', None, None, None),
+        ('boundary_condition_data_temperature', None, None, None),
+    ]
+    for table, parent, fk, model in tables:
+        if model is None:
+            rows = connection.execute(
+                f'SELECT rowid, data0 FROM {table}'
+            ).fetchall()
+        else:
+            rows = []
+            for kind, in connection.execute(
+                f'SELECT DISTINCT type FROM {parent}'
+            ):
+                headers = model._get_ctor_from_type(kind)().header
+                if not headers or headers[0] != 'time':
+                    continue
+                rows.extend(connection.execute(
+                    f'SELECT d.rowid, d.data0 FROM {table} d JOIN {parent} p '
+                    f'ON p.pamhyr_id=d.{fk} AND p.scenario=d.scenario '
+                    f'WHERE p.type=?',
+                    (kind,)
+                ).fetchall())
+        connection.executemany(
+            f'UPDATE {table} SET data0=? WHERE rowid=?',
+            [(float(value) + offset, rowid) for rowid, value in rows]
+        )

src/Model/Tools/PamhyrDB.py

@@ -1,5 +1,5 @@
 # PamhyrDB.py -- Pamhyr abstract model database classes
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/Tools/PamhyrDict.py

@@ -1,5 +1,5 @@
 # PamhyrDict.py -- Pamhyr abstract dict for model classes
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/Tools/PamhyrList.py

@@ -1,5 +1,5 @@
 # PamhyrList.py -- Pamhyr Abstract List object for the Model
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/Tools/PamhyrListExt.py

@@ -1,5 +1,5 @@
 # PamhyrList.py -- Pamhyr Abstract List object for the Model
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/WeatherParameters/WeatherParameters.py

@@ -0,0 +1,775 @@
+# WeatherParameters.py -- Pamhyr
+# Copyright (C) 2023-2025  INRAE
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# -*- coding: utf-8 -*-
+
+import logging
+
+from tools import (
+    trace, timer,
+    old_pamhyr_date_to_timestamp,
+    date_iso_to_timestamp,
+    date_dmy_to_timestamp,
+)
+
+from Model.Tools.PamhyrDB import SQLSubModel
+from Model.Except import NotImplementedMethodeError
+from Model.Scenario import Scenario
+
+logger = logging.getLogger()
+
+
+class Data(SQLSubModel):
+    _sub_classes = []
+
+    def __init__(self,
+                 data0, data1,
+                 id: int = -1,
+                 types=[float, float],
+                 status=None,
+                 owner_scenario=-1):
+        super(Data, self).__init__(
+            id=id, status=status,
+            owner_scenario=owner_scenario
+        )
+
+        self._types = types
+        self._data = [data0, data1]
+
+    @classmethod
+    def _db_create(cls, execute, ext=""):
+        execute(f"""
+          CREATE TABLE weather_parameters_data{ext} (
+            {cls.create_db_add_pamhyr_id()},
+            deleted BOOLEAN NOT NULL DEFAULT FALSE,
+            ind INTEGER NOT NULL,
+            data0 TEXT NOT NULL,
+            data1 TEXT NOT NULL,
+            wp INTEGER,
+            {Scenario.create_db_add_scenario()},
+            {Scenario.create_db_add_scenario_fk()},
+            FOREIGN KEY(wp) REFERENCES weather_parameters(pamhyr_id),
+            PRIMARY KEY(pamhyr_id, scenario)
+          )
+        """)
+
+        return cls._create_submodel(execute)
+
+    @classmethod
+    def _db_update(cls, execute, version, data=None):
+        major, minor, release = version.strip().split(".")
+
+        if major == "0" and (int(minor) < 2 or
+                             (int(minor) == 2 and int(release) <= 7)):
+            if not cls.is_table_exists(execute, "air_temperature_data"):
+                cls._db_create(execute)
+
+        return cls._update_submodel(execute, version, data)
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = []
+        wp = data["wp"]
+        status = data['status']
+        scenario = data["scenario"]
+        loaded = data['loaded_pid']
+
+        if scenario is None:
+            return new
+
+        values = execute(
+            "SELECT pamhyr_id, deleted, " +
+            "data0, data1, scenario " +
+            "FROM weather_parameters_data " +
+            f"WHERE wp = {wp._pamhyr_id} " +
+            f"AND scenario = {scenario.id} " +
+            f"AND pamhyr_id NOT IN ({', '.join(map(str, loaded))}) " +
+            "ORDER BY ind ASC"
+        )
+
+        for v in values:
+            it = iter(v)
+
+            pid = next(it)
+            deleted = next(it)
+            data0 = wp._types[0](next(it))
+            data1 = wp._types[1](next(it))
+            owner_scenario = next(it)
+
+            nd = cls(
+                data0, data1,
+                id=pid,
+                types=wp._types,
+                status=status,
+                owner_scenario=owner_scenario
+            )
+            if deleted:
+                nd.set_as_deleted()
+
+            loaded.add(pid)
+            new.append(nd)
+
+        data["scenario"] = scenario.parent
+        new += cls._db_load(execute, data)
+        data["scenario"] = scenario
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        pid = self._pamhyr_id
+        ind = data["ind"]
+        data0 = self._db_format(str(self[0]))
+        data1 = self._db_format(str(self[1]))
+        wp = data["wp"]
+
+        execute(
+            "INSERT INTO " +
+            "weather_parameters_data (pamhyr_id, deleted, ind, " +
+            "data0, data1, wp, scenario) " +
+            f"VALUES ({pid}, {self._db_format(self.is_deleted())}, " +
+            f"{ind}, '{self._db_format(data0)}', {self._db_format(data1)}, " +
+            f"{wp._pamhyr_id}, {self._status.scenario_id}" +
+            ")"
+        )
+
+        return True
+
+    def __getitem__(self, key):
+        return self._types[key](self._data[key])
+
+    def __setitem__(self, key, value):
+        self._data[key] = self._types[key](value)
+
+    def cloned(self):
+        return Data(
+            self[0], self[1],
+            types=self._types,
+            status=self._status
+        )
+
+
+class WeatherParametersDefault(SQLSubModel):
+    def __init__(self, type: str, value: float = 0.0,
+                 id: int = -1, status=None, owner_scenario=-1):
+        super(WeatherParametersDefault, self).__init__(
+            id=id, status=status,
+            owner_scenario=owner_scenario
+        )
+
+        self._type = type
+        self._value = float(value)
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = []
+        status = data['status']
+        scenario = data["scenario"]
+        loaded = data['loaded_pid']
+
+        if scenario is None:
+            return new
+
+        table = execute(
+            "SELECT pamhyr_id, type, value, scenario " +
+            "FROM weather_parameters_default " +
+            f"WHERE scenario = {scenario.id} " +
+            f"AND pamhyr_id NOT IN ({', '.join(map(str, loaded))}) "
+        )
+
+        for row in table:
+            it = iter(row)
+
+            pid = next(it)
+            type = next(it)
+            value = next(it)
+            owner_scenario = next(it)
+
+            wp_default = cls(
+                type=type,
+                value=value,
+                id=pid,
+                status=status,
+                owner_scenario=owner_scenario
+            )
+
+            loaded.add(pid)
+            new.append(wp_default)
+
+        data["scenario"] = scenario.parent
+        new += cls._db_load(execute, data)
+        data["scenario"] = scenario
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        if not self.must_be_saved():
+            return True
+
+        execute(
+            "INSERT INTO " +
+            "weather_parameters_default(" +
+            "pamhyr_id, type, value, scenario) " +
+            "VALUES (" +
+            f"{self.id}, '{self._db_format(self._type)}', {self._value}, " +
+            f"{self._status.scenario_id}" +
+            ")"
+        )
+
+        return True
+
+    @property
+    def type(self):
+        return self._type
+
+    @property
+    def value(self):
+        return self._value
+
+    @value.setter
+    def value(self, value):
+        self._value = float(value)
+        self.modified()
+
+
+class WeatherParameters(SQLSubModel):
+    _sub_classes = [Data]
+
+    def __init__(self, id: int = -1,
+                 name: str = "",
+                 status=None, owner_scenario=-1):
+        super(WeatherParameters, self).__init__(
+            id=id, status=status,
+            owner_scenario=owner_scenario
+        )
+
+        self._name = name
+        self._type = ""
+        self._reach = None
+        self._begin_section = None
+        self._end_section = None
+        self._data = []
+        self._header = []
+        self._types = [float, float]
+
+    @classmethod
+    def _db_create(cls, execute, ext=""):
+        execute(f"""
+          CREATE TABLE weather_parameters{ext}(
+            {cls.create_db_add_pamhyr_id()},
+            deleted BOOLEAN NOT NULL DEFAULT FALSE,
+            name TEXT NOT NULL,
+            type TEXT NOT NULL,
+            reach INTEGER,
+            begin_section INTEGER,
+            end_section INTEGER,
+            {Scenario.create_db_add_scenario()},
+            {Scenario.create_db_add_scenario_fk()},
+            FOREIGN KEY(reach) REFERENCES river_reach(pamhyr_id),
+            FOREIGN KEY(begin_section)
+            REFERENCES geometry_profileXYZ(pamhyr_id),
+            FOREIGN KEY(end_section)
+            REFERENCES geometry_profileXYZ(pamhyr_id),
+            PRIMARY KEY(pamhyr_id, scenario)
+          )
+        """)
+
+        execute(f"""
+          CREATE TABLE weather_parameters_default{ext}(
+            {cls.create_db_add_pamhyr_id()},
+            type TEXT NOT NULL,
+            value FLOAT NOT NULL,
+            {Scenario.create_db_add_scenario()},
+            {Scenario.create_db_add_scenario_fk()},
+            primary KEY(pamhyr_id, scenario)
+          )
+        """)
+
+        if ext == "_tmp":
+            return True
+
+        return cls._create_submodel(execute)
+
+    @classmethod
+    def _get_ctor_from_type(cls, t):
+        from Model.WeatherParameters.WeatherParametersTypes import (
+            NotDefined, WeatherParam, AirTemperature, SpecificHumidity,
+            GlobalRadiation, ReferenceWindSpeed, GroundwaterTemperature,
+            GroundwaterFlowRate, Albedo, ShadingCoefficient, CloudCoverFraction
+        )
+
+        res = NotDefined
+        if t == "WP":
+            res = WeatherParam
+        elif t == "AT":
+            res = AirTemperature
+        elif t == "SH":
+            res = SpecificHumidity
+        elif t == "GR":
+            res = GlobalRadiation
+        elif t == "RWS":
+            res = ReferenceWindSpeed
+        elif t == "GT":
+            res = GroundwaterTemperature
+        elif t == "GFR":
+            res = GroundwaterFlowRate
+        elif t == "ALB":
+            res = Albedo
+        elif t == "SC":
+            res = ShadingCoefficient
+        elif t == "CCF":
+            res = CloudCoverFraction
+        else:
+            res = NotDefined
+        return res
+
+    @classmethod
+    def _db_update(cls, execute, version, data=None):
+        major, minor, release = version.strip().split(".")
+        created = False
+
+        if major == "0" and (int(minor) < 2 or
+                             (int(minor) == 2 and int(release) <= 7)):
+            if not cls.is_table_exists(execute, "air_temperature"):
+                cls._db_create(execute)
+                created = True
+
+        if not cls.is_table_exists(execute, "weather_parameters_default"):
+            execute(f"""
+              CREATE TABLE weather_parameters_default(
+                {cls.create_db_add_pamhyr_id()},
+                type TEXT NOT NULL,
+                value FLOAT NOT NULL,
+                {Scenario.create_db_add_scenario()},
+                {Scenario.create_db_add_scenario_fk()},
+                primary KEY(pamhyr_id, scenario)
+              )
+            """)
+
+        if not created:
+            return cls._update_submodel(execute, version, data)
+
+        return True
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = []
+        status = data['status']
+        edges = data["edges"]
+        scenario = data["scenario"]
+        loaded = data['loaded_pid']
+
+        if scenario is None:
+            return new
+
+        table = execute(
+            "SELECT pamhyr_id, deleted, name, type, " +
+            "reach, begin_section, end_section, scenario " +
+            "FROM weather_parameters " +
+            f"WHERE scenario = {scenario.id} " +
+            f"AND pamhyr_id NOT IN ({', '.join(map(str, loaded))}) "
+        )
+
+        for row in table:
+            it = iter(row)
+
+            pid = next(it)
+            deleted = next(it)
+            name = next(it)
+            t = next(it)
+            reach = next(it)
+            b_section = next(it)
+            e_section = next(it)
+            owner_scenario = next(it)
+
+            ctor = cls._get_ctor_from_type(t)
+            wp = ctor(
+                id=pid, name=name,
+                status=status,
+                owner_scenario=owner_scenario
+            )
+            wp.reach = None
+            wp._begin_section = None
+            wp._end_section = None
+
+            if reach not in (-1, None):
+                wp.reach = next(
+                    (edge for edge in edges if edge.id == reach), None
+                )
+                profiles = (
+                    wp.reach.reach.profiles
+                    if wp.reach is not None else []
+                )
+                wp._begin_section = next(
+                    (profile for profile in profiles
+                     if profile.id == b_section), None
+                )
+                wp._end_section = next(
+                    (profile for profile in profiles
+                     if profile.id == e_section), None
+                )
+
+            data["wp"] = wp
+            wp._data = Data._db_load(execute, data=data)
+
+            loaded.add(pid)
+            new.append(wp)
+
+        data["scenario"] = scenario.parent
+        new += cls._db_load(execute, data)
+        data["scenario"] = scenario
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        if not self.must_be_saved():
+            return True
+
+        data["wp"] = self
+
+        execute(
+            "DELETE FROM weather_parameters_data " +
+            f"WHERE wp = {self._pamhyr_id} " +
+            f"AND scenario = {self._status.scenario_id}"
+        )
+
+        reach = None
+        begin_section = None
+        end_section = None
+
+        if self._reach is not None:
+            reach = self._reach._pamhyr_id
+            begin_section = self._begin_section._pamhyr_id
+            end_section = self._end_section._pamhyr_id
+
+        execute(
+            "INSERT INTO " +
+            "weather_parameters(" +
+            "pamhyr_id, deleted, name, type, " +
+            "reach, begin_section, end_section, scenario) " +
+            "VALUES (" +
+            f"{self.id},  {self._db_format(self.is_deleted())}, " +
+            f"'{self._db_format(self._name)}', " +
+            f"'{self._db_format(self._type)}', {reach}, " +
+            f"{begin_section}, {end_section}, " +
+            f"{self._status.scenario_id}" +
+            ")"
+        )
+
+        ind = 0
+        for d in self._data:
+            data["ind"] = ind
+
+            d._db_save(execute, data)
+
+            ind += 1
+
+        return True
+
+    def _data_traversal(self,
+                        predicate=lambda obj, data: True,
+                        modifier=lambda obj, data: None,
+                        data={}):
+        if predicate(self, data):
+            modifier(self, data)
+
+        for d in self._data:
+            d._data_traversal(predicate, modifier, data)
+
+    def __len__(self):
+        return len(
+            list(
+                filter(
+                    lambda el: not el.is_deleted(),
+                    self._data
+                )
+            )
+        )
+
+    @classmethod
+    def compatibility(cls):
+        return ["liquid", "solid", "suspenssion"]
+
+    @classmethod
+    def time_convert(cls, data):
+        if type(data) is str:
+            if data.count("-") == 2:
+                return date_iso_to_timestamp(data)
+            if data.count("/") == 2:
+                return date_dmy_to_timestamp(data)
+            if data.count(":") == 3:
+                return old_pamhyr_date_to_timestamp(data)
+            if data.count(":") == 2:
+                return old_pamhyr_date_to_timestamp("00:" + data)
+            if data.count(".") == 1:
+                return round(float(data))
+
+        return int(data)
+
+    @property
+    def name(self):
+        if self._name == "":
+            return f"LC #{self.id}"
+
+        return self._name
+
+    @name.setter
+    def name(self, name):
+        self._name = name
+        self.modified()
+
+    @property
+    def type(self):
+        return self._type
+
+    @property
+    def reach(self):
+        return self._reach
+
+    @reach.setter
+    def reach(self, reach):
+        self._reach = reach
+        self._begin_section = None
+        self._end_section = None
+
+        if reach is not None:
+            profiles = reach.reach.profiles
+            if profiles:
+                self._begin_section = profiles[0]
+                self._end_section = profiles[-1]
+
+        self.modified()
+
+    def has_reach(self):
+        return self._reach is not None
+
+    @property
+    def begin_rk(self):
+        if self._begin_section is None:
+            return 0
+
+        return self._begin_section.rk
+
+    @property
+    def begin_section(self):
+        return self._begin_section
+
+    @begin_section.setter
+    def begin_section(self, section):
+        self._begin_section = section
+        self.modified()
+
+    @property
+    def end_rk(self):
+        if self._end_section is None:
+            return 0
+
+        return self._end_section.rk
+
+    @property
+    def end_section(self):
+        return self._end_section
+
+    @end_section.setter
+    def end_section(self, section):
+        self._end_section = section
+        self.modified()
+
+    def cloned_for(self, reach, begin_section, end_section):
+        new = type(self)(name=self._name, status=self._status)
+        new._reach = reach
+        new._begin_section = begin_section
+        new._end_section = end_section
+        new._data = [data.cloned() for data in self.data]
+        new.modified()
+        return new
+
+    @property
+    def header(self):
+        return self._header.copy()
+
+    @property
+    def data(self):
+        return list(
+            filter(
+                lambda el: not el.is_deleted(),
+                self._data
+            )
+        )
+
+    def get_type_column(self, column):
+        if 0 <= column < 2:
+            return self._types[column]
+        return None
+
+    @property
+    def _default_0(self):
+        return self._types[0](0)
+
+    @property
+    def _default_1(self):
+        return self._types[1](0.0)
+
+    def is_define(self):
+        return self._data is not None
+
+    def new_from_data(self, header, data):
+        new_0 = self._default_0
+        new_1 = self._default_1
+
+        def convert(column, value, default):
+            if value.strip() == "":
+                return default
+            return self._types[column](value.replace(",", "."))
+
+        if len(header) != 0:
+            for i in [0, 1]:
+                for j in range(len(header)):
+                    if self._header[i] == header[j] and j < len(data):
+                        if i == 0:
+                            new_0 = convert(i, data[j], new_0)
+                        else:
+                            new_1 = convert(i, data[j], new_1)
+        else:
+            if len(data) > 0:
+                new_0 = convert(0, data[0], new_0)
+            if len(data) > 1:
+                new_1 = convert(1, data[1], new_1)
+
+        return Data(new_0, new_1, status=self._status)
+
+    def add(self, index: int):
+        value = Data(self._default_0, self._default_1, status=self._status)
+        self.insert(index, value)
+        return value
+
+    def insert(self, index: int, value):
+        visible_data = self.data
+        if index < len(visible_data):
+            index = self._data.index(visible_data[index])
+        else:
+            index = len(self._data)
+        self._data.insert(index, value)
+        self.modified()
+
+    def set_data_value(self, value, column, data):
+        value[column] = self._types[column](data)
+        self.modified()
+
+    def set_deleted(self, values, deleted):
+        for value in values:
+            if deleted:
+                value.set_as_deleted()
+            else:
+                value.set_as_not_deleted()
+        self.modified()
+
+    def reorder(self, values):
+        values = iter(values)
+        self._data = [
+            value if value.is_deleted() else next(values)
+            for value in self._data
+        ]
+        self.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.modified()
+
+    def set_as_deleted_i(self, indexes):
+        for i in indexes:
+            self._data[i].set_as_deleted()
+        self.modified()
+
+    def set_as_not_deleted_i(self, indexes):
+        for i in indexes:
+            self._data[i].set_as_not_deleted()
+        self.modified()
+
+    def delete(self, els):
+        self._data = list(
+            filter(
+                lambda e: e not in els,
+                self.data
+            )
+        )
+        self.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.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):
+        self.set_data_value(self.get_i(index), column, value)
+
+    def set_i_0(self, index: int, value):
+        self._set_i_c_v(index, 0, value)
+
+    def set_i_1(self, index: int, value):
+        self._set_i_c_v(index, 1, value)
+
+    @timer
+    def convert(self, cls):
+        new = cls(name=self.name, status=self._status)
+        new.reach = self.reach
+        new.begin_section = self.begin_section
+        new.end_section = self.end_section
+
+        for i, _ in enumerate(self.data):
+            new.add(i)
+
+        for i in [0, 1]:
+            for j in [0, 1]:
+                if self._header[i] == new.header[j]:
+                    for ind, v in self.data:
+                        try:
+                            new._set_i_c_v(ind, j, v[i])
+                        except Exception as e:
+                            logger.info(e)
+
+        self.modified()
+        return new
+
+    def move_up(self, index):
+        if 0 < index < len(self):
+            data = self.data
+            data[index - 1], data[index] = data[index], data[index - 1]
+            self.reorder(data)
+
+    def move_down(self, index):
+        if 0 <= index < len(self) - 1:
+            data = self.data
+            data[index], data[index + 1] = data[index + 1], data[index]
+            self.reorder(data)

src/Model/WeatherParameters/WeatherParametersList.py

@@ -0,0 +1,234 @@
+# WeatherParametersList.py -- Pamhyr
+# Copyright (C) 2023-2025  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.PamhyrListExt import PamhyrModelList
+from Model.Except import NotImplementedMethodeError
+
+from Model.WeatherParameters.WeatherParameters import (
+    WeatherParameters,
+    WeatherParametersDefault,
+)
+from Model.WeatherParameters.WeatherParametersTypes import (
+    NotDefined, WeatherParam, AirTemperature, SpecificHumidity,
+    GlobalRadiation, ReferenceWindSpeed, GroundwaterTemperature,
+    GroundwaterFlowRate, Albedo, ShadingCoefficient, CloudCoverFraction
+)
+
+
+class WeatherParametersList(PamhyrModelList):
+    _sub_classes = [
+        WeatherParameters,
+    ]
+    _default_types = [
+        "AT", "SH", "GR", "RWS", "GT", "GFR", "ALB", "SC", "CCF"
+    ]
+    _default_values = {
+        "AT": 20.0,
+        "SH": 0.001,
+        "GR": 10.0,
+        "RWS": 1.0,
+        "GT": 0.0,
+        "GFR": 0.0,
+        "ALB": 0.06,
+        "SC": 0.15,
+        "CCF": 0.5,
+    }
+
+    def __init__(self, status=None):
+        super(WeatherParametersList, self).__init__(status=status)
+        self._default = []
+        self._init_missing_default_values()
+
+    @classmethod
+    def _db_load(cls, execute, data=None):
+        new = cls(status=data['status'])
+
+        if data is None:
+            data = {}
+
+        new._lst = WeatherParameters._db_load(
+            execute, data
+        )
+
+        data['loaded_pid'] = set()
+        new._default = WeatherParametersDefault._db_load(
+            execute, data
+        )
+        new._init_missing_default_values()
+        new._sort_default_values()
+
+        return new
+
+    def _db_save(self, execute, data=None):
+        execute(
+            "DELETE FROM weather_parameters " +
+            f"WHERE scenario = {self._status.scenario_id}"
+        )
+        execute(
+            "DELETE FROM weather_parameters_data " +
+            f"WHERE scenario = {self._status.scenario_id}"
+        )
+        execute(
+            "DELETE FROM weather_parameters_default " +
+            f"WHERE scenario = {self._status.scenario_id}"
+        )
+
+        if data is None:
+            data = {}
+
+        for wp in self._lst:
+            wp._db_save(execute, data=data)
+
+        for wp_default in self._default:
+            wp_default._db_save(execute, data=data)
+
+        return True
+
+    def _data_traversal(self,
+                        predicate=lambda obj, data: True,
+                        modifier=lambda obj, data: None,
+                        data={}):
+        if predicate(self, data):
+            modifier(self, data)
+
+        for el in self._lst:
+            el._data_traversal(predicate, modifier, data)
+
+        for el in self._default:
+            el._data_traversal(predicate, modifier, data)
+
+    def _init_missing_default_values(self):
+        existing = [wp_default.type for wp_default in self.default]
+        for type in self._default_types:
+            if type not in existing:
+                self._default.append(
+                    WeatherParametersDefault(
+                        type=type,
+                        value=self._default_values[type],
+                        status=self._status,
+                    )
+                )
+
+        self._sort_default_values()
+
+    def _sort_default_values(self):
+        self._default.sort(
+            key=lambda wp_default: self._default_types.index(wp_default.type)
+            if wp_default.type in self._default_types
+            else len(self._default_types)
+        )
+
+    def new(self, index, type="ND"):
+        if type == "AT":
+            n = AirTemperature(status=self._status)
+        elif type == "SH":
+            n = SpecificHumidity(status=self._status)
+        elif type == "GR":
+            n = GlobalRadiation(status=self._status)
+        elif type == "RWS":
+            n = ReferenceWindSpeed(status=self._status)
+        elif type == "GT":
+            n = GroundwaterTemperature(status=self._status)
+        elif type == "GFR":
+            n = GroundwaterFlowRate(status=self._status)
+        elif type == "ALB":
+            n = Albedo(status=self._status)
+        elif type == "SC":
+            n = ShadingCoefficient(status=self._status)
+        elif type == "CCF":
+            n = CloudCoverFraction(status=self._status)
+        else:
+            n = NotDefined(status=self._status)
+        self._lst.insert(index, n)
+        self._status.modified()
+        return n
+
+    def split_reach(self, reach, profile, reach1, reach2):
+        profiles = reach.reach.profiles
+        split_index = profiles.index(profile)
+        parts = [
+            (
+                reach1,
+                0,
+                split_index,
+                dict(zip(
+                    profiles[:split_index + 1],
+                    reach1.reach.profiles
+                ))
+            ),
+            (
+                reach2,
+                split_index,
+                len(profiles) - 1,
+                dict(zip(
+                    profiles[split_index:],
+                    reach2.reach.profiles
+                ))
+            ),
+        ]
+        weather_parameters = [
+            weather_parameter
+            for weather_parameter in self.lst
+            if weather_parameter.reach is reach
+        ]
+        clones = []
+
+        for weather_parameter in weather_parameters:
+            if (weather_parameter.begin_section not in profiles or
+                    weather_parameter.end_section not in profiles):
+                continue
+
+            begin = profiles.index(weather_parameter.begin_section)
+            end = profiles.index(weather_parameter.end_section)
+            lower, upper = sorted((begin, end))
+            reverse = begin > end
+
+            for new_reach, part_lower, part_upper, sections in parts:
+                clipped_lower = max(lower, part_lower)
+                clipped_upper = min(upper, part_upper)
+                if clipped_lower >= clipped_upper:
+                    continue
+
+                begin_index = clipped_upper if reverse else clipped_lower
+                end_index = clipped_lower if reverse else clipped_upper
+                clones.append(weather_parameter.cloned_for(
+                    new_reach,
+                    sections[profiles[begin_index]],
+                    sections[profiles[end_index]]
+                ))
+
+        if clones:
+            self._lst.extend(clones)
+            self._status.modified()
+
+    @property
+    def Weather_Parameters_List(self):
+        return self.lst
+
+    @property
+    def default(self):
+        return self._default.copy()
+
+    def default_for_type(self, type):
+        for wp_default in self.default:
+            if wp_default.type == type:
+                return wp_default
+        return None

src/Model/WeatherParameters/WeatherParametersTypes.py

@@ -0,0 +1,171 @@
+# LateralContributionTypes.py -- Pamhyr
+# Copyright (C) 2023-2025  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.Except import NotImplementedMethodeError
+
+from Model.WeatherParameters.WeatherParameters import WeatherParameters
+
+
+class NotDefined(WeatherParameters):
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None, owner_scenario=-1):
+        super(NotDefined, self).__init__(
+            id=id, name=name, status=status,
+            owner_scenario=owner_scenario
+        )
+
+        self._type = "ND"
+        self._header = ["x", "y"]
+
+    @property
+    def _default_0(self):
+        return 0.0
+
+
+class WeatherParam(WeatherParameters):
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None, owner_scenario=-1):
+        super(WeatherParam, self).__init__(
+            id=id, name=name, status=status,
+            owner_scenario=owner_scenario
+        )
+
+        self._type = "WP"
+        self._header = ["time", "value"]
+        self._types = [WeatherParam.time_convert, float]
+
+    @classmethod
+    def compatibility(cls):
+        return ["liquid"]
+
+
+class AirTemperature(WeatherParameters):
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None, owner_scenario=-1):
+        super(AirTemperature, self).__init__(
+            id=id, name=name, status=status,
+            owner_scenario=owner_scenario
+        )
+
+        self._type = "AT"
+        self._header = ["time", "temperature"]
+        self._types = [AirTemperature.time_convert, float]
+
+
+class SpecificHumidity(WeatherParameters):
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None, owner_scenario=-1):
+        super(SpecificHumidity, self).__init__(
+            id=id, name=name, status=status,
+            owner_scenario=owner_scenario
+        )
+
+        self._type = "SH"
+        self._header = ["time", "humidity"]
+        self._types = [SpecificHumidity.time_convert, float]
+
+
+class GlobalRadiation(WeatherParameters):
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None, owner_scenario=-1):
+        super(GlobalRadiation, self).__init__(
+            id=id, name=name, status=status,
+            owner_scenario=owner_scenario
+        )
+
+        self._type = "GR"
+        self._header = ["time", "radiation"]
+        self._types = [GlobalRadiation.time_convert, float]
+
+
+class ReferenceWindSpeed(WeatherParameters):
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None, owner_scenario=-1):
+        super(ReferenceWindSpeed, self).__init__(
+            id=id, name=name, status=status,
+            owner_scenario=owner_scenario
+        )
+
+        self._type = "RWS"
+        self._header = ["time", "wind speed"]
+        self._types = [ReferenceWindSpeed.time_convert, float]
+
+
+class GroundwaterTemperature(WeatherParameters):
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None, owner_scenario=-1):
+        super(GroundwaterTemperature, self).__init__(
+            id=id, name=name, status=status,
+            owner_scenario=owner_scenario
+        )
+
+        self._type = "GT"
+        self._header = ["time", "temperature"]
+        self._types = [GroundwaterTemperature.time_convert, float]
+
+
+class GroundwaterFlowRate(WeatherParameters):
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None, owner_scenario=-1):
+        super(GroundwaterFlowRate, self).__init__(
+            id=id, name=name, status=status,
+            owner_scenario=owner_scenario
+        )
+
+        self._type = "GFR"
+        self._header = ["time", "discharge"]
+        self._types = [GroundwaterFlowRate.time_convert, float]
+
+
+class Albedo(WeatherParameters):
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None, owner_scenario=-1):
+        super(Albedo, self).__init__(
+            id=id, name=name, status=status,
+            owner_scenario=owner_scenario
+        )
+
+        self._type = "ALB"
+        self._header = ["time", "albedo"]
+        self._types = [Albedo.time_convert, float]
+
+
+class ShadingCoefficient(WeatherParameters):
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None, owner_scenario=-1):
+        super(ShadingCoefficient, self).__init__(
+            id=id, name=name, status=status,
+            owner_scenario=owner_scenario
+        )
+
+        self._type = "SC"
+        self._header = ["time", "shading coefficient"]
+        self._types = [ShadingCoefficient.time_convert, float]
+
+
+class CloudCoverFraction(WeatherParameters):
+    def __init__(self, id: int = -1, name: str = "",
+                 status=None, owner_scenario=-1):
+        super(CloudCoverFraction, self).__init__(
+            id=id, name=name, status=status,
+            owner_scenario=owner_scenario
+        )
+
+        self._type = "CCF"
+        self._header = ["time", "cloud cover fraction"]
+        self._types = [CloudCoverFraction.time_convert, float]

src/Model/__init__.py

@@ -1,5 +1,5 @@
 # __init__.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Model/test_Model.py

@@ -1,5 +1,5 @@
 # test_Model.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -23,6 +23,8 @@ import tempfile
 from Model.Status import StudyStatus
 from Model.Study import Study
 from Model.River import River
+from Model.LateralContribution.LateralContributionTypes import LateralContrib
+from Model.HydraulicStructures.Basic.Types import DischargeWeir
 
 
 class StudyTestCase(unittest.TestCase):
@@ -62,6 +64,31 @@ class StudyTestCase(unittest.TestCase):
         study = Study.new("foo", "bar")
         self.assertNotEqual(study.river, None)
 
+    def test_save_open_study_weather_parameters_default(self):
+        study = Study.new("foo", "bar")
+        defaults = study.river.weather_parameters.default
+
+        self.assertEqual(len(defaults), 9)
+        self.assertEqual(
+            [default.value for default in defaults],
+            [20.0, 0.001, 10.0, 1.0, 0.0, 0.0, 0.06, 0.15, 0.5]
+        )
+        defaults[0].value = 12.5
+
+        dir = tempfile.mkdtemp()
+        f = os.path.join(dir, "foo.pamhyr")
+
+        study.filename = f
+        study.save()
+        study.close()
+
+        study = Study.open(f)
+        defaults = study.river.weather_parameters.default
+
+        self.assertEqual(len(defaults), 9)
+        self.assertEqual(defaults[0].type, "AT")
+        self.assertEqual(defaults[0].value, 12.5)
+
 
 class StudyScenarioTestCase(unittest.TestCase):
     def test_create_study(self):
@@ -262,3 +289,89 @@ class RiverTestCase(unittest.TestCase):
         edges = river.edges()
         self.assertEqual(edges[0], e0)
         self.assertEqual(edges[1], e1)
+
+    def test_split_reach_splits_initial_conditions(self):
+        status = StudyStatus()
+        river = River(status=status)
+        node1 = river.add_node()
+        node2 = river.add_node(x=40.0)
+        reach = river.add_edge(node1, node2)
+
+        profiles = []
+        for index in range(5):
+            profile = reach.reach.insert(index)
+            profile.rk = index * 10.0
+            profile.insert(0)
+            profiles.append(profile)
+
+        initial_conditions = river.initial_conditions.get(reach)
+        for index, profile in enumerate(profiles):
+            data = initial_conditions.new_from_data(
+                profile.rk,
+                discharge=100.0 + index,
+                elevation=10.0 + index,
+            )
+            initial_conditions.insert(index, data)
+
+        reach1, reach2 = river._split_reach(reach, profiles[2])
+        conditions1 = river.initial_conditions.get(reach1).data
+        conditions2 = river.initial_conditions.get(reach2).data
+
+        self.assertEqual(
+            [data["discharge"] for data in conditions1],
+            [100.0, 101.0, 102.0]
+        )
+        self.assertEqual(
+            [data["discharge"] for data in conditions2],
+            [102.0, 103.0, 104.0]
+        )
+        self.assertEqual(
+            [data["section"] for data in conditions1],
+            reach1.reach.profiles
+        )
+        self.assertEqual(
+            [data["section"] for data in conditions2],
+            reach2.reach.profiles
+        )
+        self.assertTrue(all(
+            data._reach is reach1 for data in conditions1
+        ))
+        self.assertTrue(all(
+            data._reach is reach2 for data in conditions2
+        ))
+
+    def test_split_reach_keeps_partial_initial_conditions_in_scope(self):
+        status = StudyStatus()
+        river = River(status=status)
+        node1 = river.add_node()
+        node2 = river.add_node(x=40.0)
+        reach = river.add_edge(node1, node2)
+
+        profiles = []
+        for index in range(5):
+            profile = reach.reach.insert(index)
+            profile.rk = index * 10.0
+            profile.insert(0)
+            profiles.append(profile)
+
+        initial_conditions = river.initial_conditions.get(reach)
+        for index in (1, 3):
+            data = initial_conditions.new_from_data(
+                profiles[index].rk,
+                discharge=100.0 + index,
+                elevation=10.0 + index,
+            )
+            initial_conditions.insert(len(initial_conditions.data), data)
+
+        reach1, reach2 = river._split_reach(reach, profiles[2])
+
+        self.assertEqual(
+            [data["discharge"]
+             for data in river.initial_conditions.get(reach1).data],
+            [101.0]
+        )
+        self.assertEqual(
+            [data["discharge"]
+             for data in river.initial_conditions.get(reach2).data],
+            [103.0]
+        )

src/Modules.py

@@ -55,7 +55,6 @@ class Modules(IterableFlag):
     RESERVOIR = auto()
     SEDIMENT_LAYER = auto()
     ADDITIONAL_FILES = auto()
-    OUTPUT_RK = auto()
     GEOTIFF = auto()
 
     # Results
@@ -81,7 +80,6 @@ class Modules(IterableFlag):
             cls.ADDITIONAL_FILES,
             cls.RESULTS,
             cls.WINDOW_LIST,
-            cls.OUTPUT_RK,
             cls.GEOTIFF
         ]
 

src/SQL.py

@@ -1,5 +1,5 @@
 # SQL.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Scripts/AScript.py

@@ -1,5 +1,5 @@
 # AScript.py -- Pamhyr abstract script class
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Scripts/Hello.py

@@ -1,5 +1,5 @@
 # Hello.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Scripts/ListSolver.py

@@ -1,5 +1,5 @@
 # ListSolver.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Scripts/MageMesh.py

@@ -1,5 +1,5 @@
 # MageMesh.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Scripts/P3DST.py

@@ -1,5 +1,5 @@
 # P3DST.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Scripts/Run.py

@@ -1,5 +1,5 @@
 # Run.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -25,6 +25,7 @@ from PyQt5.QtCore import QProcess
 
 from Scripts.AScript import AScript
 from Model.Study import Study
+from View.RunSolver.Translate import RunSolverTranslate
 
 logger = logging.getLogger()
 
@@ -75,7 +76,8 @@ class ScriptRun(AScript):
             os.path.dirname(study.filename),
             "_PAMHYR_",
             study.name.replace(" ", "_"),
-            solver.name.replace(" ", "_")
+            solver.name.replace(" ", "_"),
+            study.status.scenario.workdir(),
         )
         os.makedirs(workdir, exist_ok=True)
         logger.info(f"Set working dir to {workdir}")
@@ -88,12 +90,16 @@ class ScriptRun(AScript):
 
         # Export and Run
         logger.info(f"~Export~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
-        solver.export(study, workdir, qlog=self._q)
+        ok = solver.export(study, workdir, qlog=self._q)
 
         while self._q.qsize() != 0:
             s = self._q.get()
             logger.info(s)
 
+        if not ok:
+            logger.warning(RunSolverTranslate()["export_failed"])
+            return
+
         if command == "run":
             logger.info(f"~Run~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
             solver.run(

src/Scripts/mage_to_mascaret.py

@@ -1,3 +1,20 @@
+# mage_to_mascaret.py -- Pamhyr
+# Copyright (C) 2026  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 -*-
 #!/bin/env python3
 
 import sys
@@ -336,6 +353,3 @@ if __name__ == "__main__":
     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

@@ -1,3 +1,20 @@
+# mascaret_to_mage.py -- Pamhyr
+# Copyright (C) 2026  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 -*-
 #!/bin/env python3
 
 import sys

src/Solver/ASolver.py

@@ -1,5 +1,5 @@
 # ASolver.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -79,7 +79,7 @@ class AbstractSolver(object):
     def default_parameters(cls):
         lst = [
             ("all_init_time", "000:00:00:00"),
-            ("all_final_time", "999:99:00:00"),
+            ("all_final_time", "10:00:00:00"),
             ("all_timestep", "300.0"),
         ]
 

src/Solver/AdisTS.py

@@ -1,5 +1,5 @@
 # AdisTS.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -35,10 +35,6 @@ from Solver.CommandLine import CommandLineSolver
 from Model.Results.ResultsAdisTS import Results
 from Model.Results.River.River import River, Reach, Profile
 
-from Checker.Adists import (
-    AdistsOutputRKChecker,
-)
-
 from itertools import chain
 
 logger = logging.getLogger()
@@ -90,11 +86,7 @@ class AdisTS(CommandLineSolver):
 
     @classmethod
     def checkers(cls):
-        lst = [
+        return []
-            AdistsOutputRKChecker(),
-        ]
-
-        return lst
 
     ##########
     # Export #
@@ -117,9 +109,6 @@ class AdisTS(CommandLineSolver):
     _nodes_names = {}
     _nodes_views = set()
 
-    def get_reach_name(self, reach):
-        return f"Reach_{reach.pamhyr_id:>3}".replace(" ", "0")
-
     def get_node_name(self, node):
         """Generate a 3 char name for node
 
@@ -182,7 +171,7 @@ class AdisTS(CommandLineSolver):
         # Write header
         edges = study.river.enable_edges()
         for edge in edges:
-            name = f"Reach_{edge.id + 1:>3}".replace(" ", "0")
+            name = self.get_reach_name(edge)
 
             with adists_file_open(
                     os.path.join(repertory, "net", f"{name}.ST"),
@@ -191,7 +180,7 @@ class AdisTS(CommandLineSolver):
                 files.append(str(os.path.join("net", f"{name}.ST")))
 
                 cnt_num = 1
-                for profile in edge.reach.profiles:
+                for profile in edge.reach.enabled_profiles:
                     self._export_ST_profile_header(
                         f, files, profile, cnt_num
                     )
@@ -277,11 +266,11 @@ class AdisTS(CommandLineSolver):
             edges = study.river.enable_edges()
 
             for e in edges:
-                name = f"Reach_{e.id + 1:>3}".replace(" ", "0")
+                name = self.get_reach_name(e)
                 id = name
 
-                n1 = f"{e.node1.id:3}".replace(" ", "x")
+                n1 = f"{self.get_node_name(e.node1):3}".replace(" ", "x")
-                n2 = f"{e.node2.id:3}".replace(" ", "x")
+                n2 = f"{self.get_node_name(e.node2):3}".replace(" ", "x")
                 file = os.path.join("net", name + ".ST")
 
                 f.write(f"{id} {n1} {n2} {file}\n")
@@ -346,7 +335,7 @@ class AdisTS(CommandLineSolver):
 
                     return coeff.minor, coeff.medium
 
-                for j, profile in enumerate(edge.reach.profiles):
+                for j, profile in enumerate(edge.reach.enabled_profiles):
                     coef_min, coef_moy = get_stricklers_from_rk(profile.rk,
                                                                 lst)
                     f.write(
@@ -366,13 +355,19 @@ class AdisTS(CommandLineSolver):
         if qlog is not None:
             qlog.put("Export REP file")
 
+        mage_path = (mage_rep if os.path.isabs(mage_rep) else os.path.join(
+            os.path.abspath(os.path.join(repertory, os.pardir)),
+            mage_rep,
+        ))
+        relative_mage_path = os.path.relpath(mage_path, repertory)
+
         # Write header
         with adists_file_open(
                 os.path.join(
                     repertory, f"{name}.REP"
                 ), "w+"
         ) as f:
-            path = os.path.join("..", mage_rep, name)
+            path = os.path.join(relative_mage_path, name)
             f.write(f"NET {name}.NET\n")
             f.write(f"REP {path}.REP\n")
 
@@ -387,9 +382,7 @@ class AdisTS(CommandLineSolver):
 
         # fake mage_fin.ini:
 
-        path_mage = os.path.join(os.path.abspath(
+        self._export_fake_INI(study, mage_path,
-                os.path.join(repertory, os.pardir)), mage_rep)
-        self._export_fake_INI(study, path_mage,
                               qlog, name=name)
 
         # path_mage_net = os.path.join(os.path.abspath(
@@ -415,6 +408,41 @@ class AdisTS(CommandLineSolver):
     # RESULTS #
     ###########
 
+    @staticmethod
+    def _remove_temperature_results(repertory):
+        """Remove temperature outputs generated but unused by AdisTS."""
+        results_directory = os.path.join(repertory, "resultats")
+        if not os.path.isdir(results_directory):
+            results_directory = repertory
+
+        if not os.path.isdir(results_directory):
+            return
+
+        for filename in os.listdir(results_directory):
+            if not (filename.startswith("TEM.") or
+                    filename.startswith("TEM_")):
+                continue
+
+            filepath = os.path.join(results_directory, filename)
+            if os.path.isfile(filepath):
+                try:
+                    os.remove(filepath)
+                    logger.debug(
+                        f"Removed unused AdisTS result '{filepath}'"
+                    )
+                except OSError as error:
+                    logger.warning(
+                        f"Unable to remove AdisTS result '{filepath}': "
+                        f"{error}"
+                    )
+
+    def run_output_data_fomater(self, study):
+        # AdisTS generates temperature results that are not used by the solver,
+        # but they are still present in the output directory.
+        # Remove them to avoid confusion.
+        self._remove_temperature_results(self._process.workingDirectory())
+        return super(AdisTS, self).run_output_data_fomater(study)
+
     def read_bin(self, study, repertory, results, qlog=None, name="0"):
         return
 
@@ -453,48 +481,8 @@ class AdisTS(CommandLineSolver):
     _nodes_views = set()
 
     def get_reach_name(self, reach):
-        return f"Reach_{reach.pamhyr_id:>3}".replace(" ", "0")
+        index = self._study.river.get_edge_id(reach) + 1
-
+        return f"Reach_{index:03d}"
-    def get_node_name(self, node):
-        """Generate a 3 char name for node
-
-        Args:
-            node: The node
-
-        Returns:
-            A 3 char name string
-        """
-        n = node.pamhyr_id
-
-        # print("node name id: ", n)
-
-        # if n in self._nodes_names:
-        #     return self._nodes_names[n]
-
-        name = ""
-
-        checked_new = False
-        while not checked_new:
-            self._nodes_cnt += 1
-            nc = self._nodes_cnt
-
-            name = "".join(
-                map(
-                    lambda i: self._alph[i % self._l_alph],
-                    [
-                        int(nc / (self._l_alph * self._l_alph)),
-                        int(nc / self._l_alph),
-                        nc
-                    ]
-                )
-            )
-
-            checked_new = name not in self._nodes_views
-
-        self._nodes_views.add(name)
-        self._nodes_names[n] = name
-
-        return name
 
 #################################
 # Adis-TS in weak coupling mode #
@@ -548,12 +536,13 @@ class AdisTSwc(AdisTS):
                         study, pollutant._data, f, qlog
                 )
 
-                POL_ICs = next(filter(
+                POL_ICs = next((
-                    lambda ic: ic.pollutant == pollutant.id,
+                    ic for ic in
                     study.river.ic_adists.Initial_Conditions_List
-                ))
+                    if ic.pollutant == pollutant.id
+                ), None)
 
-                if POL_ICs.concentration is not None:
+                if POL_ICs is not None and POL_ICs.concentration is not None:
                     f.write(f"file_ini = {name}.INI\n")
                     self._export_ICs_AdisTS(
                         study, repertory, POL_ICs, qlog, name
@@ -593,15 +582,18 @@ class AdisTSwc(AdisTS):
             os.path.join(repertory, f"{POL_name}.ALD"), "w+"
         ) as f:
             for LC in POL_LC:
-                reach = next(filter(
+                reach = next((
-                    lambda edge: edge.id == LC.edge, study.river.enable_edges()
+                    edge for edge in study.river.enable_edges()
-                ))  # .name
+                    if edge.id == LC.reach
+                ), None)
+                if reach is None:
+                    continue
                 reach_name = self.get_reach_name(reach)
                 f.write(f"${reach_name} {LC.begin_rk} {LC.end_rk}\n")
                 f.write(f"*temps   |débit massique (kg/s)\n")
                 f.write(f"*---------++++++++++\n")
 
-                for LC_data in LC._data:
+                for LC_data in LC.data:
                     tmp = timestamp_to_old_pamhyr_date_adists(int(LC_data[0]))
                     f.write(" ".join((f"{tmp}",
                             f"{LC_data[1]}\n")))
@@ -618,9 +610,10 @@ class AdisTSwc(AdisTS):
             repertory, f"{POL_name}.CDT"), "w+"
         ) as f:
             for BC in POL_BC:
-                node = next(filter(
+                node = next((node for node in study.river.nodes()
-                    lambda x: x.id == BC.node, study.river._nodes
+                             if node.id == BC.node), None)
-                ))
+                if node is None:
+                    continue
                 f.write(f"${self.get_node_name(node)}\n")
 
                 if BC.type == "Concentration":
@@ -632,7 +625,7 @@ class AdisTSwc(AdisTS):
                     f.write(f"*JJ:HH:MM | (kg/s)\n")
                     f.write(f"*---------++++++++++\n")
 
-                for BC_data in BC._data:
+                for BC_data in BC.data:
                     tmp = timestamp_to_old_pamhyr_date_adists(int(BC_data[0]))
                     f.write(" ".join((f"{tmp}",
                             f"{BC_data[1]}\n")))
@@ -666,6 +659,9 @@ class AdisTSwc(AdisTS):
 
         edges = study.river.enable_edges()
         for ic_spec in pol_ics_spec_data:
+            if ic_spec.is_deleted():
+                continue
+
             id_reach = ic_spec.reach
             reach = next((x for x in edges if x.id == id_reach), None)
             if reach is None:
@@ -689,7 +685,9 @@ class AdisTSwc(AdisTS):
         list_characteristics = ["type", "diametre", "rho", "porosity",
                                 "cdc_riv", "cdc_cas", "apd", "ac", "bc"]
 
-        if len(list_characteristics) <= (len(pol_data[0])):
+        pol_data = [data for data in pol_data if not data.is_deleted()]
+
+        if pol_data and len(list_characteristics) <= len(pol_data[0]):
             for i in range(len(list_characteristics)):
                 f.write(f"{list_characteristics[i]} = {pol_data[0][i]}\n")
 
@@ -718,6 +716,9 @@ class AdisTSwc(AdisTS):
     def _export_d90_spec(self, study, d90_spec_data, f, qlog, name="0"):
 
         for d90_spec in d90_spec_data:
+            if d90_spec.is_deleted():
+                continue
+
             if (d90_spec.name is None
                     or d90_spec.reach is None
                     or d90_spec.start_rk is None
@@ -777,6 +778,9 @@ class AdisTSwc(AdisTS):
     def _export_dif_spec(self, study, dif_spec_data, f, qlog, name="0"):
 
         for dif_spec in dif_spec_data:
+            if dif_spec.is_deleted():
+                continue
+
             if (dif_spec.reach is None
                     or dif_spec.start_rk is None
                     or dif_spec.end_rk is None
@@ -844,33 +848,8 @@ class AdisTSwc(AdisTS):
                 if name != "command_line_arguments":
                     f.write(f"{dict_names[name]} = {value}\n")
 
-            outputrks = study.river.Output_rk_adists.OutputRK_List
-
-            for outputrk in outputrks:
-                self._export_outputrk(study, outputrk, f, qlog)
-
         return files
 
-    def _export_outputrk(self, study, outputrk, f, qlog, name="0"):
-        if (outputrk.reach is None
-                or outputrk.rk is None
-                or outputrk.title is None):
-            return
-
-        edges = study.river.enable_edges()
-
-        id_edges = list(map(lambda x: x.id, edges))
-
-        id_reach = outputrk.reach
-        reach = next((x for x in edges if x.id == id_reach), None)
-        rk = outputrk.rk
-        title = outputrk.title
-
-        if reach is None:
-            return
-
-        f.write(f"output = {study.river.get_edge_id(reach)+1} {rk} {title}\n")
-
     @timer
     def read_bin(self, study, repertory, results, qlog=None, name="0"):
 
@@ -917,7 +896,10 @@ class AdisTSwc(AdisTS):
 
             for i in range(ibmax):
                 # Add results reach to reach list
-                r = results.river.add(i)
+                geometry_reach = study.river.enable_edges()[i].reach
+                r = results.river.add(
+                    i, profiles=geometry_reach.enabled_profiles
+                )
                 reachs.append(r)
 
                 is1[i] = data[2 * i] - 1  # first section of reach i

src/Solver/CommandLine.py

@@ -1,5 +1,5 @@
 # CommandLine.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -19,8 +19,9 @@
 import os
 import logging
 
-from datetime import datetime
+from datetime import datetime, timezone
 from tools import timer, parse_command_line, get_version, logger_exception
+from tools import parse_datetime
 
 try:
     # Installation allow Unix-like signal
@@ -158,11 +159,15 @@ class CommandLineSolver(AbstractSolver):
             txt = add_file.text
             txt = txt.replace("@version", get_version())
             txt = txt.replace("@date", datetime.now().isoformat(sep=" "))
+            txt = self._prepare_additional_file_text(add_file.path, txt)
 
             f.write(txt)
 
         return files
 
+    def _prepare_additional_file_text(self, path, text):
+        return text
+
     def export_study_description(self, study, repertory, qlog, name="0"):
         files = []
 

src/Solver/GenericSolver.py

@@ -1,5 +1,5 @@
 # GenericSolver.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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

src/Solver/Mage.py

@@ -1,5 +1,5 @@
 # Mage.py -- Pamhyr
-# Copyright (C) 2023-2025  INRAE
+# Copyright (C) 2023-2026  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
@@ -65,6 +65,8 @@ class Mage(CommandLineSolver):
         self._cmd_solver = "@path @input -o @output"
         self._cmd_output = ""
 
+        self._reset_node_names()
+
     @classmethod
     def default_parameters(cls):
         lst = super(Mage, cls).default_parameters()
@@ -125,12 +127,15 @@ class Mage(CommandLineSolver):
 
     _l_alph = len(_alph)
 
-    _nodes_cnt = 0
+    def _reset_node_names(self):
-    _nodes_names = {}
+        """Reset the node-name registry for a new export."""
-    _nodes_views = set()
+        self._nodes_cnt = 0
+        self._nodes_names = {}
+        self._nodes_views = set()
 
     def get_reach_name(self, reach):
-        return f"Reach_{reach.pamhyr_id:>3}".replace(" ", "0")
+        index = self._study.river.get_edge_id(reach) + 1
+        return f"Reach_{index:03d}"
 
     def get_node_name(self, node):
         """Generate a 3 char name for node
@@ -210,7 +215,7 @@ class Mage(CommandLineSolver):
         # Write header
         edges = study.river.enable_edges()
         for edge in edges:
-            name = f"Reach_{edge.pamhyr_id:>3}".replace(" ", "0")
+            name = self.get_reach_name(edge)
 
             with mage_file_open(
                     os.path.join(repertory, "net", f"{name}.ST"),
@@ -219,7 +224,7 @@ class Mage(CommandLineSolver):
                 files.append(str(os.path.join("net", f"{name}.ST")))
 
                 cnt_num = 1
-                for profile in edge.reach.profiles:
+                for profile in edge.reach.enabled_profiles:
                     self._export_ST_profile_header(
                         f, files, profile, cnt_num
                     )
@@ -298,7 +303,7 @@ class Mage(CommandLineSolver):
         # Point line
         wfile.write(f"{x} {y} {z} {n} {sediment}\n")
 
-    def _export_BC(self, t, bounds, repertory, qlog, name="0"):
+    def _export_BC(self, study, t, bounds, repertory, qlog, name="0"):
         files = []
 
         if len(bounds) == 0:
@@ -328,7 +333,7 @@ class Mage(CommandLineSolver):
                     v1 = d[1]
 
                     if t in ["HYD", "LIM"]:
-                        v0 /= 60  # Convert first column to minute
+                        v0 /= 60  # Convert first column to minutes
 
                     f.write(f"{v0:9} {v1:9} \n")
 
@@ -360,10 +365,17 @@ class Mage(CommandLineSolver):
                 elif bound.bctype == "SL":
                     QSO.append(bound)
 
-        files = files + self._export_BC("AVA", AVA, repertory, qlog, name=name)
+        files = files + self._export_BC(
-        files = files + self._export_BC("HYD", HYD, repertory, qlog, name=name)
+            study, "AVA", AVA, repertory, qlog, name=name
-        files = files + self._export_BC("LIM", LIM, repertory, qlog, name=name)
+        )
-        files = files + self._export_QSO(QSO, repertory, qlog, name=name)
+        files = files + self._export_BC(
+            study, "HYD", HYD, repertory, qlog, name=name
+        )
+        files = files + self._export_BC(
+            study, "LIM", LIM, repertory, qlog, name=name
+        )
+        files = files + self._export_QSO(study, QSO, repertory,
+                                         qlog, name=name)
 
         return files
 
@@ -407,7 +419,7 @@ class Mage(CommandLineSolver):
         # name = f"Reach_{lateral.reach.id + 1:>3}".replace(" ", "0")
         f.write(f"* {lateral.reach.name} ({name}) {lateral.lctype}\n")
         f.write(
-            f"${name}    " +
+            f"${name}     " +
             f"{lateral.begin_rk:>10.4f} {lateral.end_rk:>10.4f}\n"
         )
         header = lateral.header
@@ -417,10 +429,11 @@ class Mage(CommandLineSolver):
             if d.is_deleted():
                 continue
 
+            time = d[0]
             if lateral.lctype in ["EV"]:
-                f.write(f"{d[0]:10.3f}{-d[1]:10.3f}\n")
+                f.write(f"{time:10.3f}{-d[1]:10.3f}\n")
             else:
-                f.write(f"{d[0]:10.3f}{d[1]:10.3f}\n")
+                f.write(f"{time:10.3f}{d[1]:10.3f}\n")
 
     def _export_RUG(self, study, repertory, qlog, name="0"):
         files = []
@@ -484,7 +497,12 @@ class Mage(CommandLineSolver):
                 if cond.is_deleted():
                     continue
 
-                data = cond.data
+                enabled_profiles = set(reach.reach.enabled_profiles)
+                data = [
+                    item for item in cond.data
+                    if not item.is_deleted()
+                    and item["section"] in enabled_profiles
+                ]
                 if len(data) == 0:
                     continue
 
@@ -492,9 +510,6 @@ class Mage(CommandLineSolver):
 
                 id_sec = 1
                 for d in data:
-                    if d.is_deleted():
-                        continue
-
                     IR = f"{id}"
                     IS = f"{id_sec}"
                     discharge = f"{d['discharge']:>10.5f}"
@@ -679,6 +694,23 @@ class Mage(CommandLineSolver):
 
         return res
 
+    def _prepare_additional_file_text(self, path, text):
+        if os.path.splitext(path)[1].lower() != ".var":
+            return text
+
+        lines = []
+        for line in text.splitlines(keepends=True):
+            stripped = line.lstrip()
+            fields = stripped.split()
+            if stripped.startswith("$"):
+                # MAGE only recognizes rule markers in the first column.
+                line = stripped
+            elif (not stripped.startswith("*") and len(fields) >= 2
+                  and fields[1] == "W2Z"):
+                line = "$ " + stripped
+            lines.append(line)
+        return "".join(lines)
+
     def _export_VAR(self, study, repertory, qlog, name="0"):
         files = []
 
@@ -729,9 +761,11 @@ class Mage(CommandLineSolver):
                         name = bhs.name
                         if name == "":
                             name = f"HS_{bhs.id:>3}".replace(" ", "0")
+                        else:
+                            name = name.replace(" ", "_")
 
                         f.write(
-                            f"${name} clapet"
+                            f"${name} clapet\n"
                         )
         return files
 
@@ -957,7 +991,7 @@ class Mage8(Mage):
 
         return files
 
-    def _export_QSO(self, bounds, repertory, qlog, name="0"):
+    def _export_QSO(self, study, bounds, repertory, qlog, name="0"):
         files = []
 
         if len(bounds) == 0:
@@ -987,7 +1021,8 @@ class Mage8(Mage):
 
                 # Data
                 for d in bound.data:
-                    f.write(f"{d[0]/60:10.3f}{d[1]:10.3f}\n")
+                    time = d[0] / 60
+                    f.write(f"{time:10.3f}{d[1]:10.3f}\n")
 
         return files
 
@@ -1004,6 +1039,7 @@ class Mage8(Mage):
     @timer
     def export(self, study, repertory, qlog=None, name="0"):
         self._study = study
+        self._reset_node_names()
         name = study.name.replace(" ", "_")
 
         # Define GRA file name
@@ -1083,7 +1119,7 @@ class Mage8(Mage):
             newline()
 
             reachs = []
-            iprofiles = {}
+            iprofiles = []
             profile_len = []
             reach_offset = {}
 
@@ -1091,22 +1127,28 @@ class Mage8(Mage):
 
             for i in range(nb_reach):
                 # Add results reach to reach list
-                r = results.river.add(i)
+                geometry_reach = study.river.enable_edges()[i].reach
+                r = results.river.add(
+                    i, profiles=geometry_reach.enabled_profiles
+                )
                 reachs.append(r)
 
                 # ID of first and last reach profiles
                 i1 = data[2*i] - 1
                 i2 = data[2*i+1] - 1
 
+                # Keep profiles index of all river
+                r.set_global_index(range(i1, i2 + 1))
+
                 # Add profile id correspondance to reach
-                key = (i1, i2)
+                for key in range(i1, i2 + 1):
-                iprofiles[key] = r
+                    iprofiles.append(i)
 
                 # Profile ID offset
                 reach_offset[r] = i1
-                profile_len.append(i2-i1+1)
+                profile_len.append(i2 - i1 + 1)
 
-            logger.debug(f"read_bin: iprofiles = {iprofiles}")
+            logger.debug(f"read_bin: iprofiles = {len(iprofiles)}")
 
             endline()
 
@@ -1124,16 +1166,6 @@ class Mage8(Mage):
             # Data
             newline()
 
-            def ip_to_r(i): return iprofiles[
-                next(
-                    filter(
-                        lambda k: k[0] <= i <= k[1],
-                        iprofiles
-                    )
-                )
-            ]
-            def ip_to_ri(r, i): return i - reach_offset[r]
-
             # check results and geometry consistency
             for i, r in enumerate(reachs):
                 lp = len(r.profiles)
@@ -1144,6 +1176,8 @@ class Mage8(Mage):
                     return
 
             ts = set()
+            tmp_table = {}
+
             end = False
             while not end:
                 n = read_int(1)[0]
@@ -1152,18 +1186,21 @@ class Mage8(Mage):
                     f, dtype=np.byte, count=1)).decode()
                 data = read_float(n)
 
-                # logger.debug(f"read_bin: timestamp = {timestamp} sec")
+                if key not in tmp_table:
+                    tmp_table[key] = []
+
+                tmp_table[key].append(data)
                 ts.add(timestamp)
 
                 if key in ["Z", "Q"]:
                     for i, d in enumerate(data):
                         # Get reach corresponding to profile ID
-                        reach = ip_to_r(i)
+                        reach = reachs[iprofiles[i]]
                         # Get profile id in reach
-                        ri = ip_to_ri(reach, i)
+                        ri = i - reach_offset[reach]
 
                         # Set data for profile RI
-                        reach.set(ri, timestamp, key, d)
+                        # reach.set(ri, timestamp, key, d)
                         if key == "Z":
                             profile = reach.profile(ri)
                             limits = profile.geometry.get_water_limits(d)
@@ -1176,6 +1213,15 @@ class Mage8(Mage):
                 endline()
                 end = newline().size <= 0
 
+            ts_index = {}
+            for i, t in enumerate(sorted(ts)):
+                ts_index[t] = i
+            results.set_timestamp_index(ts_index)
+
+            table = {}
+            for k in tmp_table:
+                table[k] = np.array(tmp_table[k])
+
             results.set("timestamps", ts)
             ts_list = sorted(ts)
             logger.info(f"compute tab...")
@@ -1185,19 +1231,33 @@ class Mage8(Mage):
 
             logger.info(f"compute velocity...")
 
-            for r in reachs:
+            velocity_arr = np.zeros((len(ts), len(iprofiles)))
-                for t in ts_list:
+            for ti, t in enumerate(ts_list):
-                    for i, p in enumerate(r.profiles):
+                j = 0
+                for r in reachs:
+                    for pi, p in enumerate(r.profiles):
                         v = p.geometry.speed(
-                                p.get_ts_key(t, "Q"),
+                            table["Q"][ti, p.global_index],
-                                p.get_ts_key(t, "Z")
+                            table["Z"][ti, p.global_index],
                         )
-                        r.set(i, t, "V", v)
+                        # r.set(pi, t, "V", v)
+                        velocity_arr[ti, j] = v
+                        j += 1
+
+            table["V"] = velocity_arr
+
+            for legend in table:
+                table[legend] = results.new_table_data(
+                    legend, table[legend]
+                )
+
+            results.set("table", table)
+
             logger.info(f"read_bin: ... end with {len(ts)} timestamp read")
 
-        results.bufferize("Z")
+        # results.bufferize("Z")
-        results.bufferize("Q")
+        # results.bufferize("Q")
-        results.bufferize("V")
+        # results.bufferize("V")
         logger.info(f"reading time: '{time.time() - start}'")
 
     @timer
@@ -1267,8 +1327,8 @@ class Mage8(Mage):
                 reachs.append(r)
 
                 # ID of first and last reach profiles
-                i1 = data[2*i] - 1
+                i1 = data[2 * i] - 1
-                i2 = data[2*i+1] - 1
+                i2 = data[2 * i + 1] - 1
 
                 # Add profile id correspondance to reach
                 key = (i1, i2)
@@ -1322,6 +1382,7 @@ class Mage8(Mage):
                     newline()
                     npts = read_int(n)
                     endline()
+
                 sum_npts = sum(npts)
                 logger.debug(f"read_gra: Number of points: {sum_npts}")
 
@@ -1371,35 +1432,45 @@ class Mage8(Mage):
 
             logger.info(f"compute river bed elevation...")
 
+            zfd_lst = []
+
             for r in reachs:
-                z_min = r.geometry.get_z_min()
+                z_min = [
-                sls = list(map(
+                    profile.geometry.z_min()
+                    for profile in r.profiles
+                ]
+                sls = map(
                     lambda p: p.get_ts_key(ts_list[0], "sl")[0],
                     r.profiles
-                    ))
+                )
                 z_br = list(map(
-                            lambda z, sl: reduce(
+                    lambda z, sl: reduce(
-                                lambda z, h: z - h[0],
+                        lambda z, h: z - h[0],
-                                sl, z
+                        sl, z
-                            ),
+                    ),
-                            z_min,          # Original geometry
+                    z_min,          # Original geometry
-                            sls             # Original sediment layers
+                    sls             # Original sediment layers
-                            ))
+                ))
-                for t in ts_list:
+                for its, t in enumerate(ts_list):
-                    sls = list(map(
+                    sls = map(
                         lambda p: p.get_ts_key(t, "sl")[0],
                         r.profiles
-                        ))
+                    )
                     zfd = list(map(
-                                lambda z, sl: reduce(
+                        lambda z, sl: reduce(
-                                    lambda z, h: z + h[0],
+                            lambda z, h: z + h[0],
-                                    sl, z
+                            sl, z
-                                ),
+                        ),
-                                z_br,       # bedrock
+                        z_br,       # bedrock
-                                sls         # Original sediment layers
+                        sls         # Original sediment layers
-                            ))
+                    ))
-                    for i, p in enumerate(r.profiles):
+
-                        r.set(i, t, "zfd", zfd[i])
+                    zfd_lst.append(np.array(zfd))
+
+            table = results.get("table")
+            table["zfd"] = results.new_table_data(
+                "zfd", np.array(zfd_lst)
+            )
 
             results.set("sediment_timestamps", ts)
             logger.info(f"read_gra: ... end with {len(ts)} timestamp read")

src/Solver/RubarBE.py

@@ -18,11 +18,14 @@
 
 import os
 import logging
+import math
+from decimal import Decimal, InvalidOperation, localcontext
 import numpy as np
 
 from tools import timer, trace, old_pamhyr_date_to_timestamp, logger_exception
 
 from Solver.CommandLine import CommandLineSolver
+from View.RunSolver.Translate import RunSolverTranslate
 
 from Model.Results.Results import Results
 from Model.Results.River.River import River, Reach, Profile
@@ -44,7 +47,7 @@ class Rubar3(CommandLineSolver):
 
     @classmethod
     def default_parameters(cls):
-        # lst = super(Rubar3, cls).default_parameters()
+        # Keep historical rubarbe_* keys for existing Rubar3 studies.
 
         lst = [
             ("rubarbe_cfl", "0.50000E+00"),
@@ -52,13 +55,13 @@ class Rubar3(CommandLineSolver):
             ("rubarbe_condav", "3"),
             ("rubarbe_regime", "0"),
             ("rubarbe_iodev", "n"),
-            ("rubarbe_iodebord", ""),
+            ("rubarbe_iodebord", "o"),
-            ("rubarbe_iostockage", ""),
+            ("rubarbe_iostockage", "o"),
             ("rubarbe_iopdt", "y"),
             ("rubarbe_iovis", "n"),
             ("rubarbe_rep", "n"),
             ("rubarbe_tinit", "000:00:00:00"),
-            ("rubarbe_tmax", "000:01:00:00"),  # 1 day
+            ("rubarbe_tmax", "001:00:00:00"),  # 1 day
             ("rubarbe_tiopdt", "000:00:00:00"),
             ("rubarbe_dt", "5.0"),
             ("rubarbe_ts", "999:99:99:00"),
@@ -89,8 +92,8 @@ class Rubar3(CommandLineSolver):
             ("rubarbe_sediment_mult_3", ""),
             ("rubarbe_sediment_mult_4", ""),
             ("rubarbe_sediment_mult_5", ""),
-            ("rubarbe_sediment_visc", "0.047"),
+            ("rubarbe_sediment_visc", "1.3E-06"),
-            ("rubarbe_sediment_opts", "6"),
+            ("rubarbe_sediment_opts", "3"),
             ("rubarbe_sediment_odchar", "0"),
             ("rubarbe_sediment_unisol", "1"),
             ("rubarbe_sediment_typdef", "3"),
@@ -140,8 +143,34 @@ class Rubar3(CommandLineSolver):
         self._study = study
         name = study.name.replace(" ", "_")
 
+        values = self._parameter_values(study)
+        if (values.get("rubarbe_regime") == "1" and
+                values.get("rubarbe_condam") == "0"):
+            trad = RunSolverTranslate()
+            message = trad["incompatible_upstream_boundary"]
+            logger.warning(message)
+            if qlog is not None:
+                qlog.put(trad["warning"].format(message=message))
+            return False
+
+        trased = self._parameter_flag(study, "trased") == "O"
+        if trased:
+            # Notice §3.6: HYDROS is required at each upstream boundary
+            missing = self._reaches_without_solid_boundary(study)
+            if missing:
+                trad = RunSolverTranslate()
+                message = trad["missing_solid_boundary"].format(
+                    reaches=", ".join(missing)
+                )
+                logger.warning(message)
+                if qlog is not None:
+                    qlog.put(trad["warning"].format(message=message))
+                return False
+
         self._export_donnee(study, repertory, qlog, name=name)
-        self._export_ts(study, repertory, qlog, name=name)
+        if trased:
+            if not self._export_ts(study, repertory, qlog, name=name):
+                return False
         self._export_geomac_i(study, repertory, qlog, name=name)
         self._export_mail(study, repertory, qlog, name=name)
         self._export_devers(study, repertory, qlog, name=name)
@@ -153,108 +182,205 @@ class Rubar3(CommandLineSolver):
 
         return True
 
-    def _export_donnee(self, study, repertory, qlog, name="0"):
+    # Notice Rubar3/RubarBE, annex 1: records are positional, not keyed.
+    # Each record starts with an A50 label, including records of integers.
+    _donnee_fields = (
+        ("cfl", "real"),
+        ("condam", "integer"), ("condav", "integer"),
+        ("regime", "integer"), ("iodev", "flags"),
+        ("iopdt", "flag"), ("iovis", "flag"), ("rep", "flag"),
+        ("tinit", "time"), ("tmax", "time"), ("tiopdt", "time"),
+        ("dt", "real"), ("ts", "time"), ("dtsauv", "time"),
+        ("psave", "time"), ("fdeb1", "real"), ("fdeb2", "real"),
+        ("fdeb3", "real"),
+        ("tf_1", "flag"), ("tf_2", "flag"), ("tf_3", "flag"),
+        ("tf_4", "flag"), ("tf_5", "flag"), ("tf_6", "flag"),
+        ("trased", "flag"),
+    )
+    _ts_fields = (
+        ("ros", "real"), ("por", "real"), ("dcharg", "real"),
+        ("halfa", "real"), ("mult_1", "multipliers"),
+        ("visc", "real"), ("opts", "law"), ("odchar", "integer"),
+        ("unisol", "integer"), ("typdef", "integer"),
+        ("depot", "depot"), ("choixc", "integer"),
+        ("option", "options"), ("capsol", "integer"),
+        ("bmiu", "real"), ("demix", "integer"),
+        ("defond", "integer"), ("varcons", "integer"),
+    )
+
+    @staticmethod
+    def _reaches_without_solid_boundary(study):
+        river = study.river
+        solid = [
+            bc for bc in river.boundary_condition.get_tab("solid")
+            if not bc.is_deleted() and bc.bctype == "SL" and len(bc) > 0
+        ]
+
+        return [
+            edge.name for edge in river.enable_edges()
+            if river.is_upstream_node(edge.node1)
+            and not any(bc.node == edge.node1 for bc in solid)
+        ]
+
+    def _parameter_values(self, study):
+        return {p.name: str(p.value).strip()
+                for p in study.river.get_params(self.type).parameters}
+
+    @staticmethod
+    def _required(values, key):
+        value = values.get(key, "")
+        if not value:
+            raise ValueError(f"Missing Rubar parameter: {key}")
+        return value
+
+    @staticmethod
+    def _flag(value, key, mixed=False):
+        result = value.upper()
+        if result == "Y":
+            result = "O"
+        if result not in (("O", "N", "M") if mixed else ("O", "N")):
+            raise ValueError(f"{key}: expected O/Y or N" +
+                             (" or M" if mixed else ""))
+        return result
+
+    def _parameter_flag(self, study, suffix):
+        key = "rubarbe_" + suffix
+        return self._flag(self._required(self._parameter_values(study), key),
+                          key)
+
+    @staticmethod
+    def _integer(value, key, width=1):
+        if not value.isascii() or not value.isdigit() or len(value) > width:
+            raise ValueError(f"{key}: expected an integer in {width} columns")
+        return value.rjust(width)
+
+    @staticmethod
+    def _real(value, key, scientific=False):
+        try:
+            number = Decimal(value.replace("d", "E").replace("D", "E"))
+        except InvalidOperation:
+            raise ValueError(f"{key}: invalid real value {value!r}") from None
+        if not number.is_finite():
+            raise ValueError(f"{key}: expected a finite real value")
+        if scientific:
+            # DONNEE: E12.5. Reject overflow instead of shifting columns.
+            floating = float(number)
+            if not math.isfinite(floating) or (number and floating == 0):
+                raise ValueError(f"{key}: real value outside E12.5 range")
+            result = f"{floating:12.5E}"
+            width = 12
+        else:
+            # TS: F10.0 input accepts an explicit decimal point/exponent.
+            # Preserve the value exactly; do not round porosity etc. to int.
+            with localcontext() as context:
+                context.prec = max(28, len(number.as_tuple().digits))
+                number = number.normalize()
+            result = str(number).upper()
+            if len(result) > 10:
+                result = format(number, "E")
+            width = 10
+        if len(result) > width:
+            raise ValueError(f"{key}: value {value!r} exceeds {width} columns")
+        return result.rjust(width)
+
+    @staticmethod
+    def _write_parameters(repertory, filename, lines):
+        # Validate all records before opening/truncating the destination.
+        path = os.path.join(repertory, filename)
+        with open(path, "w", encoding="ascii") as f:
+            f.writelines(lines)
+
+    def _export_donnee(self, study, repertory, qlog=None, name="0"):
+        values = self._parameter_values(study)
+        fields = list(self._donnee_fields)
+        # The diagnostic transport-capacity extension is optional as a block.
+        if values.get("rubarbe_optfpc", ""):
+            fields += [("optfpc", "integer"), ("ros", "real"),
+                       ("dm", "real"), ("segma", "real")]
+        elif any(values.get("rubarbe_" + key, "")
+                 for key in ("ros", "dm", "segma")):
+            raise ValueError("rubarbe_optfpc: required before ROS/DM/SEGMA")
+        lines = []
+        for suffix, kind in fields:
+            key = "rubarbe_" + suffix
+            value = self._required(values, key)
+            if kind == "integer":
+                result = self._integer(value, key)
+            elif kind in ("flag", "flags"):
+                result = self._flag(value, key, mixed=suffix == "iopdt")
+                if kind == "flags":
+                    # Missing optional flags mean O (notice section 3.1).
+                    # Write both explicitly so STOCKAGE cannot shift left.
+                    for extra in ("iodebord", "iostockage"):
+                        extra_key = "rubarbe_" + extra
+                        result += self._flag(values.get(extra_key) or "O",
+                                             extra_key)
+            else:
+                if kind == "time" and ":" in value:
+                    parts = value.split(":")
+                    if len(parts) != 4 or not all(p.isdigit() for p in parts):
+                        raise ValueError(
+                            f"{key}: expected days:hours:minutes:seconds")
+                    value = str(old_pamhyr_date_to_timestamp(value))
+                result = self._real(value, key, scientific=True)
+            lines.append(f"{key:<50}{result}\n")
         if qlog is not None:
             qlog.put("Export DONNEE file")
+        self._write_parameters(repertory, f"donnee.{name}", lines)
 
-        with open(
+    def _export_ts(self, study, repertory, qlog=None, name="0"):
-                os.path.join(
+        trad = RunSolverTranslate()
-                    repertory, f"donnee.{name}"
+        values = self._parameter_values(study)
-                ), "w+"
+        prefix = "rubarbe_sediment_"
-        ) as f:
+        fields = list(self._ts_fields)
-            params = filter(
+        demix = self._required(values, prefix + "demix")
-                lambda p: "rubarbe_sediment_" not in p.name,
+        if demix not in ("0", "1"):
-                study.river.get_params(self._type).parameters
+            raise ValueError(f"{prefix}demix: expected 0 or 1")
-            )
+        if demix == "1":
-
+            fields += [("dchard", "real"), ("dchars", "real")]
-            it = iter(params)
+        lines = []
-
+        for suffix, kind in fields:
-            param = next(it, None)
+            key = prefix + suffix
-            while param is not None:
+            value = self._required(values, key)
-                name = param.name
+            if kind == "real":
-                value = param.value
+                result = self._real(value, key)
-
+            elif kind == "multipliers":
-                if "all_" in name:
+                result = self._real(value, key)
-                    continue
+                extras = [values.get(prefix + f"mult_{i}", "")
-
+                          for i in range(2, 6)]
-                if value != "":
+                # Preserve empty interior F10.0 fields; omit trailing fields
-                    # Value format
+                # to retain the solver's defaults for optional coefficients.
-                    if value.count(':') == 3:
+                while extras and not extras[-1]:
-                        value = old_pamhyr_date_to_timestamp(value)
+                    extras.pop()
-                        value = f"{value:>12.5e}".upper()
+                for i, extra in enumerate(extras, 2):
-
+                    result += (self._real(extra, prefix + f"mult_{i}")
-                    if value.count('.') == 1:
+                               if extra else " " * 10)
-                        value = f"{float(value):>12.5e}".upper()
+            elif kind == "options":
-
+                if len(value) != 3 or any(c not in "12" for c in value):
-                    if value == "y" or value == "n":
+                    message = trad["invalid_options"].format(key=key)
-                        value = "O" if value == "y" else "N"
+                    logger.warning(message)
-
+                    if qlog is not None:
-                    # Write value
+                        qlog.put(trad["warning"].format(message=message))
-                    f.write(f"{name:<50}{value}")
+                    return False
-
+                result = value
-                    # Add values of 'rubarbe_iodebord' and
+            elif kind == "law":
-                    # 'rubarbe_iostockage'
+                # Notice section 3.10 / 8.7: 4--7 are not listed.
-                    if name == "rubarbe_iodev":
+                if value not in {str(i) for i in [1, 2, 3, *range(8, 31)]}:
-                        v2 = next(it).value
+                    message = trad["unsupported_transport_law"].format(
-                        v3 = next(it).value
+                        key=key, value=value)
-
+                    logger.warning(message)
-                        # f.write(f"{v2}{v3}")
+                    if qlog is not None:
-
+                        qlog.put(trad["warning"].format(message=message))
-                    # New line
+                    return False
-                    f.write(f"\n")
+                result = self._integer(value, key, width=2)
-
+            else:
-                param = next(it, None)
+                result = self._integer(value, key,
-
+                                       width=10 if kind == "depot" else 1)
-    def _export_ts(self, study, repertory, qlog, name="0"):
+            lines.append(f"{key:<50}{result}\n")
         if qlog is not None:
             qlog.put("Export TS file")
-
+        self._write_parameters(repertory, f"ts.{name}", lines)
-        with open(
+        return True
-                os.path.join(
-                    repertory, f"ts.{name}"
-                ), "w+"
-        ) as f:
-            def float_format(string):
-                if "." in string:
-                    return f"{float(string):>10.0f}"
-                return ""
-
-            params = filter(
-                lambda p: "rubarbe_sediment_" in p.name,
-                study.river.get_params(self.type).parameters
-            )
-            it = iter(params)
-
-            line = 0
-            while line < 20:
-                param = next(it)
-                name = param.name
-                value = param.value
-
-                if value != "":
-                    # Value format
-                    if value.count('.') == 1:
-                        value = f"{float_format(value)}"
-                    else:
-                        value = f"{value:>10}"
-
-                    # Write value
-                    f.write(f"{name:<50}{value}")
-
-                    # Add values of 'rubarbe_iodebord' and
-                    # 'rubarbe_iostockage'
-                    if name == "rubarbe_sediment_mult_1":
-                        m2 = f"{float_format(next(it).value)}"
-                        m3 = f"{float_format(next(it).value)}"
-                        m4 = f"{float_format(next(it).value)}"
-                        m5 = f"{float_format(next(it).value)}"
-
-                        f.write(f"{m2}{m3}{m4}{m5}")
-
-                    # New line
-                    f.write(f"\n")
-
-                line += 1
 
     def _export_geomac_i(self, study, repertory, qlog, name="0"):
         if qlog is not None:
@@ -616,6 +742,7 @@ class Rubar3(CommandLineSolver):
             )).value
             if timestamp.count(':') == 3:
                 timestamp = old_pamhyr_date_to_timestamp(timestamp)
+            timestamp = float(timestamp)
             ts.add(timestamp)
 
             # add initial condition
@@ -636,8 +763,7 @@ class Rubar3(CommandLineSolver):
             while True:
                 line = f.readline()
                 if line == "":
-                    results.set("timestamps", ts)
+                    break
-                    return
 
                 timestamp = float(line)
                 ts.add(timestamp)
@@ -671,6 +797,24 @@ class Rubar3(CommandLineSolver):
                     h, s, q, z = read_data_line(f)
                     set_and_compute_limites(reach, ind, z+h, q, s)
 
+            # Tables and plots use timestamp rows and global profile columns.
+            timestamps = sorted(ts)
+            profiles = []
+            for reach, _ in reachs:
+                offset = len(profiles)
+                profiles.extend(reach.profiles)
+                reach.set_global_index(range(offset, len(profiles)))
+
+            results.set("timestamps", timestamps)
+            results.compute_timestamp_index()
+            results.set("table", {
+                key: np.array([
+                    [profile.get_ts_key(t, key) for profile in profiles]
+                    for t in timestamps
+                ], dtype=float)
+                for key in ("Z", "Q", "V")
+            })
+
     @timer
     def write_bin(self, study, fname, results, qlog=None, name="0"):
         logger.info(f"write_bin: Start writing '{fname}' ...")
@@ -800,3 +944,14 @@ class RubarBE(Rubar3):
         self._cmd_input = ""
         self._cmd_solver = "@path @args @input"
         self._cmd_output = ""
+
+    @classmethod
+    def default_parameters(cls):
+        # New BE studies evolve the bed. Keep Rubar3 defaults unchanged.
+        overrides = {
+            "rubarbe_trased": "y",
+            "rubarbe_sediment_opts": "1",  # Meyer-Peter and Mueller
+            "rubarbe_sediment_option": "212",  # no Ikeda, given Shields, total
+        }
+        return [(key, overrides.get(key, value))
+                for key, value in super().default_parameters()]