Temperature: propagate TEM when splitting reach

src/Meshing/Internal.py

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

src/Model/InitialConditionsTemperature/InitialConditionsTemperature.py

@@ -227,3 +227,42 @@ class InitialConditionsTemperature(SQLSubModel):
             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

@@ -62,6 +62,12 @@ class InitialConditionsTemperatureList(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/InitialConditionsTemperature/InitialConditionsTemperatureSpec.py

@@ -200,3 +200,15 @@ class ICTemperatureSpec(SQLSubModel):
     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/LateralContributionsAdisTS/LateralContributionAdisTS.py

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

@@ -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/River.py

@@ -991,5 +991,14 @@ Last export at: @date."""
         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
+        )
 
         return r1, r2

src/Model/SolverParameters/SolverParametersList.py

@@ -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/WeatherParameters/WeatherParameters.py

@@ -153,6 +153,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 WeatherParametersDefault(SQLSubModel):
     def __init__(self, type: str, value: float = 0.0,
@@ -580,6 +587,15 @@ class WeatherParameters(SQLSubModel):
         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()

src/Model/WeatherParameters/WeatherParametersList.py

@@ -161,6 +161,64 @@ class WeatherParametersList(PamhyrModelList):
         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

src/Solver/AdisTS.py

@@ -549,7 +549,7 @@ class AdisTSwc(AdisTS):
             for LC in POL_LC:
                 reach = next((
                     edge for edge in study.river.enable_edges()
-                    if edge.id == LC.edge
+                    if edge.id == LC.reach
                 ), None)
                 if reach is None:
                     continue

src/Solver/AdisTT.py

@@ -935,7 +935,8 @@ class AdisTTwc(AdisTT):
         for weather_parameter in study.river.weather_parameters.lst:
             config = self._weather_files.get(weather_parameter.type)
             if (config is None or weather_parameter.reach is None
-                    or weather_parameter.reach.is_deleted()):
+                    or weather_parameter.reach.is_deleted()
+                    or not weather_parameter.reach.is_enable()):
                 continue
             _, extension = config
             exported = self._export_weather_file(

src/Solver/Mage.py

@@ -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,9 +127,11 @@ class Mage(CommandLineSolver):
 
     _l_alph = len(_alph)
 
-    _nodes_cnt = 0
-    _nodes_names = {}
-    _nodes_views = set()
+    def _reset_node_names(self):
+        """Reset the node-name registry for a new export."""
+        self._nodes_cnt = 0
+        self._nodes_names = {}
+        self._nodes_views = set()
 
     def get_reach_name(self, reach):
         index = self._study.river.get_edge_id(reach) + 1
@@ -1005,6 +1009,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

src/View/BoundaryCondition/Edit/Table.py

@@ -143,21 +143,43 @@ class TableModel(PamhyrTableModel):
         self.update()
 
     def delete(self, rows, parent=QModelIndex()):
-        self.beginRemoveRows(parent, rows[0], rows[-1])
+        if not rows:
+            return
 
-        rows = list(map(
-            lambda r: self.get_true_data_row(r),
-            rows))
+        rows = sorted(set(rows))
+        rows = [
+            self.get_true_data_row(row)
+            for row in rows
+        ]
 
+        # A multiple selection may contain non-contiguous rows. A model reset
+        # accurately represents this atomic undo command, unlike one
+        # beginRemoveRows() call spanning rows that are not all removed.
+        self.beginResetModel()
+        try:
             self._undo.push(
                 DelCommand(
                     self._data, rows
                 )
             )
-
-        self.endRemoveRows()
+        finally:
+            self.endResetModel()
         self.update()
 
+    def undo(self):
+        self.beginResetModel()
+        try:
+            self._undo.undo()
+        finally:
+            self.endResetModel()
+
+    def redo(self):
+        self.beginResetModel()
+        try:
+            self._undo.redo()
+        finally:
+            self.endResetModel()
+
     def sort(self, _reverse, parent=QModelIndex()):
         self.layoutAboutToBeChanged.emit()
 

src/View/BoundaryCondition/Edit/UndoCommand.py

@@ -97,12 +97,11 @@ class DelCommand(QUndoCommand):
         QUndoCommand.__init__(self)
 
         self._data = data
-        self._rows = rows
-
-        self._bc = []
-        for row in rows:
-            self._bc.append(self._data.get_i(row))
-        self._bc.sort()
+        self._rows = sorted(set(rows))
+        self._bc = [
+            self._data.get_i(row)
+            for row in self._rows
+        ]
 
     def undo(self):
         for el in self._bc:
@@ -120,13 +119,17 @@ class SortCommand(QUndoCommand):
         self._data = data
         self._reverse = _reverse
 
-        self._old = self._data.data
-        self._indexes = None
+        # Keep the order of the complete underlying list, including soft
+        # deleted items. ``data`` only exposes visible items and therefore
+        # cannot reliably restore a sort after a delete/undelete operation.
+        self._old_positions = {
+            id(item): index
+            for index, item in enumerate(self._data._data)
+        }
 
     def undo(self):
-        ll = self._data.data
         self._data.sort(
-            key=lambda x: self._indexes[ll.index(x)]
+            key=lambda item: self._old_positions[id(item)]
         )
 
     def redo(self):
@@ -134,14 +137,6 @@ class SortCommand(QUndoCommand):
             _reverse=self._reverse,
             key=lambda x: x[0]
         )
-        if self._indexes is None:
-            self._indexes = list(
-                map(
-                    lambda p: self._old.index(p),
-                    self._data.data
-                )
-            )
-            self._old = None
 
 
 class MoveCommand(QUndoCommand):

src/View/D90AdisTS/Table.py

@@ -78,7 +78,7 @@ class ComboBoxDelegate(QItemDelegate):
         else:
             val = list(
                 map(
-                    lambda n: n.name, self._data.edges()
+                    lambda n: n.name, self._data.enable_edges()
                 )
             )
 

src/View/DIFAdisTS/Table.py

@@ -80,7 +80,7 @@ class ComboBoxDelegate(QItemDelegate):
         else:
             val = list(
                 map(
-                    lambda n: n.name, self._data.edges()
+                    lambda n: n.name, self._data.enable_edges()
                 )
             )
 

src/View/Geometry/Table.py

@@ -259,6 +259,9 @@ class GeometryReachTableModel(PamhyrTableModel):
                 **data
             )
 
+        self.apply_meshing(new_profiles, data, tableView)
+
+    def apply_meshing(self, new_profiles, data, tableView):
         if new_profiles is None:
             return
 

src/View/Geometry/Window.py

@@ -350,14 +350,22 @@ class GeometryWindow(PamhyrWindow):
             tableview = self.tableView
 
             def fn():
-                self._table.meshing(mesher, data, tableview)
-            # self._table.meshing(mesher, data, tableview)
+                return mesher.meshing(self._reach, **data)
+
             dlg2 = WaitingDialog(
                 payload_fn=fn,
                 title="waiting_mesh",
                 parent=self
             )
             dlg2.exec_()
+
+            if dlg2.worker_exception is not None:
+                raise dlg2.worker_exception
+
+            # Models, undo stacks and selections belong to the GUI thread.
+            self._table.apply_meshing(
+                dlg2.worker_result, data, tableview
+            )
             self._table.update()
 
         except Exception as e:

src/View/InitialConditionsTemperature/Table.py

@@ -75,7 +75,7 @@ class ComboBoxDelegate(QItemDelegate):
         else:
             val = list(
                 map(
-                    lambda n: n.name, self._data.edges()
+                    lambda n: n.name, self._data.enable_edges()
                 )
             )
 
@@ -140,13 +140,30 @@ class InitialConditionTableModel(PamhyrTableModel):
         self._data = data
 
     def _setup_lst(self):
+        enabled_reach_ids = {
+            reach.id
+            for reach in self._river.enable_edges()
+        }
         self._lst = list(
             filter(
-                lambda ica: ica._deleted is False,
+                lambda ica: (
+                    ica._deleted is False and
+                    (
+                        ica.reach in (None, -1) or
+                        ica.reach in enabled_reach_ids
+                    )
+                ),
                 self._data._data
             )
         )
 
+    def refresh(self):
+        self.beginResetModel()
+        try:
+            self._setup_lst()
+        finally:
+            self.endResetModel()
+
     def rowCount(self, parent):
         return len(self._lst)
 
@@ -221,19 +238,30 @@ class InitialConditionTableModel(PamhyrTableModel):
                     )
                 )
             else:
+                new_value = value
+                if self._headers[column] == "reach":
+                    reach = self._river.edge(value)
+                    rks = reach.reach.get_rk()
+                    if not rks:
+                        return False
+                    new_value = (reach.id, min(rks))
+
                 self._undo.push(
                     SetCommandSpec(
                         self._lst, row, self._headers[column],
-                        (self._river.edge(value).id
-                         if self._headers[column] == "reach"
-                         else value
-                         )
+                        new_value
                     )
                 )
         except Exception as e:
             logger.info(e)
             logger.debug(traceback.format_exc())
 
+        if self._headers[column] == "reach":
+            rk_index = self.index(
+                row, self._headers.index("rk")
+            )
+            self.dataChanged.emit(index, rk_index)
+        else:
             self.dataChanged.emit(index, index)
         return True
 

src/View/InitialConditionsTemperature/UndoCommand.py

@@ -73,6 +73,8 @@ class SetCommandSpec(QUndoCommand):
             self._old = self._data[self._row].name
         elif self._column == "reach":
             self._old = self._data[self._row].reach
+            self._old_start_rk = self._data[self._row].start_rk
+            self._old_end_rk = self._data[self._row].end_rk
         elif self._column == "rk":
             self._old = self._data[self._row].start_rk
         elif self._column == "temperature":
@@ -84,6 +86,10 @@ class SetCommandSpec(QUndoCommand):
         elif column == "reach":
             _type = int
 
+        if column == "reach":
+            self._new = _type(new_value[0])
+            self._new_rk = float(new_value[1])
+        else:
             self._new = _type(new_value)
 
     def undo(self):
@@ -91,6 +97,8 @@ class SetCommandSpec(QUndoCommand):
             self._data[self._row].name = self._old
         elif self._column == "reach":
             self._data[self._row].reach = self._old
+            self._data[self._row].start_rk = self._old_start_rk
+            self._data[self._row].end_rk = self._old_end_rk
         elif self._column == "rk":
             self._data[self._row].start_rk = self._old
             self._data[self._row].end_rk = self._old
@@ -102,6 +110,8 @@ class SetCommandSpec(QUndoCommand):
             self._data[self._row].name = self._new
         elif self._column == "reach":
             self._data[self._row].reach = self._new
+            self._data[self._row].start_rk = self._new_rk
+            self._data[self._row].end_rk = self._new_rk
         elif self._column == "rk":
             self._data[self._row].start_rk = self._new
             self._data[self._row].end_rk = self._new

src/View/InitialConditionsTemperature/Window.py

@@ -309,3 +309,10 @@ class InitialConditionsTemperatureWindow(PamhyrWindow):
         if len(rows) == 0:
             return
         self._table_spec.delete(rows)
+
+    def _propagated_update(self, key=Modules(0)):
+        if Modules.NETWORK not in key:
+            return
+
+        self._table_spec.refresh()
+        self.table_spec.clearSelection()

src/View/LateralContributionsAdisTS/Table.py

@@ -81,7 +81,10 @@ class ComboBoxDelegate(QItemDelegate):
         else:
             self.editor.addItems(
                 [self._trad['not_associated']] +
-                self._data.edges_names()
+                [
+                    reach.name
+                    for reach in self._data.enable_edges()
+                ]
             )
 
         self.editor.setCurrentText(index.data(Qt.DisplayRole))
@@ -119,6 +122,11 @@ class TableModel(PamhyrTableModel):
         self._setup_lst()
 
     def _setup_lst(self):
+        enabled_reach_ids = {
+            reach.id
+            for reach in self._data.enable_edges()
+        }
+
         if self._lcs_list is not None:
             self._lcs_pol_list = [
                 lcs for lcs in self._lcs_list._lst
@@ -127,7 +135,13 @@ class TableModel(PamhyrTableModel):
 
         self._lst = list(
             filter(
-                lambda x: x._deleted is False,
+                lambda x: (
+                    x._deleted is False and
+                    (
+                        x.reach in (None, -1) or
+                        x.reach in enabled_reach_ids
+                    )
+                ),
                 self._lcs_pol_list
             )
         )
@@ -137,6 +151,18 @@ class TableModel(PamhyrTableModel):
     def rowCount(self, parent):
         return len(self._lst)
 
+    def get(self, row):
+        if 0 <= row < len(self._lst):
+            return self._lst[row]
+        return None
+
+    def refresh(self):
+        self.beginResetModel()
+        try:
+            self._setup_lst()
+        finally:
+            self.endResetModel()
+
     def data(self, index, role):
         if role != Qt.ItemDataRole.DisplayRole:
             return QVariant()
@@ -170,11 +196,18 @@ class TableModel(PamhyrTableModel):
 
         try:
             if self._headers[column] == "reach":
+                reach = self._data.reach(value)
+                rks = reach.reach.get_rk()
+                if len(rks) == 0:
+                    return False
+
                 self._undo.push(
                     SetReachCommand(
                         self._lcs_list, self._lst,
                         row,
-                        self._data.reach(value).id
+                        reach.id,
+                        min(rks),
+                        max(rks)
                     )
                 )
             elif self._headers[column] == "begin_rk":
@@ -193,6 +226,12 @@ class TableModel(PamhyrTableModel):
             logger.info(e)
             logger.debug(traceback.format_exc())
 
+        if self._headers[column] == "reach":
+            end_index = self.index(
+                row, self._headers.index("end_rk")
+            )
+            self.dataChanged.emit(index, end_index)
+        else:
             self.dataChanged.emit(index, index)
         return True
 

src/View/LateralContributionsAdisTS/UndoCommand.py

@@ -64,20 +64,30 @@ class SetEndCommand(QUndoCommand):
 
 
 class SetReachCommand(QUndoCommand):
-    def __init__(self, lcs, lcs_lst, index, reach):
+    def __init__(self, lcs, lcs_lst, index, reach, begin_rk, end_rk):
         QUndoCommand.__init__(self)
 
         self._lcs = lcs
         self._lcs_lst = lcs_lst
         self._index = index
         self._old = self._lcs_lst[self._index].reach
+        self._old_begin_rk = self._lcs_lst[self._index].begin_rk
+        self._old_end_rk = self._lcs_lst[self._index].end_rk
         self._new = reach
+        self._new_begin_rk = begin_rk
+        self._new_end_rk = end_rk
 
     def undo(self):
-        self._lcs_lst[self._index].reach = self._old
+        contribution = self._lcs_lst[self._index]
+        contribution.reach = self._old
+        contribution.begin_rk = self._old_begin_rk
+        contribution.end_rk = self._old_end_rk
 
     def redo(self):
-        self._lcs_lst[self._index].reach = self._new
+        contribution = self._lcs_lst[self._index]
+        contribution.reach = self._new
+        contribution.begin_rk = self._new_begin_rk
+        contribution.end_rk = self._new_end_rk
 
 
 class AddCommand(QUndoCommand):

src/View/LateralContributionsAdisTS/Window.py

@@ -20,6 +20,7 @@ import logging
 
 from tools import trace, timer
 
+from Modules import Modules
 from View.Tools.PamhyrWindow import PamhyrWindow
 
 from PyQt5.QtGui import (
@@ -187,12 +188,13 @@ class LateralContributionAdisTSWindow(PamhyrWindow):
         data = None
         highlight = None
 
-        tab = "liquid"
-
         if len(rows) > 0:
-            reach_id = self._study.river\
-                       .lateral_contributions_adists.lst[rows[0]]\
-                       .reach
+            contribution = self._table.get(rows[0])
+            reach_id = (
+                contribution.reach
+                if contribution is not None
+                else None
+            )
 
             if reach_id:
                 reach = next(
@@ -201,8 +203,10 @@ class LateralContributionAdisTSWindow(PamhyrWindow):
                         self._study.river.reachs()))
 
                 data = reach.reach
-                lc = self._lcs.lst[rows[0]]
-                highlight = (lc.begin_rk, lc.end_rk)
+                highlight = (
+                    contribution.begin_rk,
+                    contribution.end_rk
+                )
 
                 for delegate in self._delegate_rk:
                     delegate.data = reach
@@ -254,13 +258,23 @@ class LateralContributionAdisTSWindow(PamhyrWindow):
         self._table.redo()
         self._set_current_reach()
 
+    def _propagated_update(self, key=Modules(0)):
+        if Modules.NETWORK not in key:
+            return
+
+        self._table.refresh()
+        self.find(QTableView, "tableView").clearSelection()
+        self._set_current_reach()
+
     def edit(self):
         rows = self.index_selected_rows()
         if not rows:
             return
 
         for row in rows:
-            data = self._lcs.lst[row]
+            data = self._table.get(row)
+            if data is None:
+                continue
 
             if self.sub_window_exists(
                 EditLateralContributionAdisTSWindow,

src/View/RunSolver/Window.py

@@ -82,7 +82,9 @@ class SelectSolverWindow(PamhyrDialog):
         # solvers = self._config.solvers
         # solvers mage
         solvers = list(filter(
-            lambda x: "adists" not in x._type, self._config.solvers
+            lambda x: "adists" not in x._type
+            and "adistt" not in x._type,
+            self._config.solvers
         ))
         solvers_name = list(
             map(

src/View/WaitingDialog.py

@@ -47,9 +47,15 @@ class Worker(QObject):
         super(self.__class__, self).__init__(parent)
 
         self._payload_fn = payload_fn
+        self.result = None
+        self.exception = None
 
     def process(self):
-        self._payload_fn()
+        try:
+            self.result = self._payload_fn()
+        except Exception as exception:
+            self.exception = exception
+        finally:
             self.signalStatus.emit('end')
 
 
@@ -123,6 +129,14 @@ class WaitingDialog(PamhyrDialog):
         self._timer = QTimer(self)
         self._timer.timeout.connect(self.update_spinner)
 
+    @property
+    def worker_result(self):
+        return self._worker.result
+
+    @property
+    def worker_exception(self):
+        return self._worker.exception
+
     def update_spinner(self):
         self._spinner_step += 1
         self._spinner_step %= len(self._spin)

src/View/WeatherParameters/Table.py

@@ -87,7 +87,10 @@ class ComboBoxDelegate(QItemDelegate):
         else:
             self.editor.addItems(
                 [self._trad['not_associated']] +
-                self._data.edges_names()
+                [
+                    reach.name
+                    for reach in self._data.enable_edges()
+                ]
             )
 
         self.editor.setCurrentText(str(index.data(Qt.DisplayRole)))
@@ -144,8 +147,28 @@ class WeatherParametersTableModel(PamhyrTableModel):
         if self._type == "ND" or self._data is None:
             self._lst = []
             return
+        enabled_reach_ids = {
+            reach.id
+            for reach in self._river.enable_edges()
+        }
         self._lst = self._data.lst
-        self._lst = list(filter(lambda wp: wp.type == self._type, self._lst))
+        self._lst = list(filter(
+            lambda wp: (
+                wp.type == self._type and
+                (
+                    wp.reach is None or
+                    wp.reach.id in enabled_reach_ids
+                )
+            ),
+            self._lst
+        ))
+
+    def refresh(self):
+        self.beginResetModel()
+        try:
+            self._setup_lst()
+        finally:
+            self.endResetModel()
 
     def update_tab_spec(self, type="ND", enabled=True):
         if enabled:
@@ -239,15 +262,24 @@ class WeatherParametersTableModel(PamhyrTableModel):
                     )
                 )
             elif self._headers[column] == "reach":
+                edge = self._river.edge(value)
+                if not edge.reach.profiles:
+                    return False
                 self._undo.push(
                     SetEdgeCommand(
-                        self._data, global_row, self._river.edge(value)
+                        self._data, global_row, edge
                     )
                 )
         except Exception as e:
             logger.info(e)
             logger.debug(traceback.format_exc())
 
+        if self._headers[column] == "reach":
+            end_index = self.index(
+                row, self._headers.index("end_rk")
+            )
+            self.dataChanged.emit(index, end_index)
+        else:
             self.dataChanged.emit(index, index)
         return True
 

src/View/WeatherParameters/UndoCommand.py

@@ -125,14 +125,26 @@ class SetEdgeCommand(QUndoCommand):
 
         self._wps = wps
         self._index = index
-        self._old = self._wps.get(self._index).reach
+        weather_parameter = self._wps.get(self._index)
+        self._old = weather_parameter.reach
+        self._old_begin = weather_parameter.begin_section
+        self._old_end = weather_parameter.end_section
         self._new = edge
+        profiles = edge.reach.profiles
+        self._new_begin = min(profiles, key=lambda profile: profile.rk)
+        self._new_end = max(profiles, key=lambda profile: profile.rk)
 
     def undo(self):
-        self._wps.get(self._index).reach = self._old
+        weather_parameter = self._wps.get(self._index)
+        weather_parameter.reach = self._old
+        weather_parameter.begin_section = self._old_begin
+        weather_parameter.end_section = self._old_end
 
     def redo(self):
-        self._wps.get(self._index).reach = self._new
+        weather_parameter = self._wps.get(self._index)
+        weather_parameter.reach = self._new
+        weather_parameter.begin_section = self._new_begin
+        weather_parameter.end_section = self._new_end
 
 
 class AddCommand(QUndoCommand):

src/View/WeatherParameters/Window.py

@@ -439,3 +439,10 @@ class WeatherParametersWindow(PamhyrWindow):
                 parent=self
             )
             win.show()
+
+    def _propagated_update(self, key=Modules(0)):
+        if Modules.NETWORK not in key:
+            return
+
+        self._table_spec.refresh()
+        self.table_spec.clearSelection()