src/Meshing/Internal.py

@@ -57,13 +57,6 @@ 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:
@@ -72,12 +65,6 @@ 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,42 +227,3 @@ 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,12 +62,6 @@ 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,15 +200,3 @@ 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,13 +192,6 @@ 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]
@@ -484,18 +477,6 @@ 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,46 +68,6 @@ 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,14 +991,5 @@ 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,9 +216,6 @@ 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,13 +153,6 @@ 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,
@@ -587,15 +580,6 @@ 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,64 +161,6 @@ 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.reach
+                    if edge.id == LC.edge
                 ), None)
                 if reach is None:
                     continue

src/Solver/AdisTT.py

@@ -935,8 +935,7 @@ 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,8 +65,6 @@ 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()
@@ -127,11 +125,9 @@ class Mage(CommandLineSolver):
 
     _l_alph = len(_alph)
 
-    def _reset_node_names(self):
+    _nodes_cnt = 0
-        """Reset the node-name registry for a new export."""
+    _nodes_names = {}
-        self._nodes_cnt = 0
+    _nodes_views = set()
-        self._nodes_names = {}
-        self._nodes_views = set()
 
     def get_reach_name(self, reach):
         index = self._study.river.get_edge_id(reach) + 1
@@ -1009,7 +1005,6 @@ 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,43 +143,21 @@ class TableModel(PamhyrTableModel):
         self.update()
 
     def delete(self, rows, parent=QModelIndex()):
-        if not rows:
+        self.beginRemoveRows(parent, rows[0], rows[-1])
-            return
 
-        rows = sorted(set(rows))
+        rows = list(map(
-        rows = [
+            lambda r: self.get_true_data_row(r),
-            self.get_true_data_row(row)
+            rows))
-            for row in rows
-        ]
 
-        # A multiple selection may contain non-contiguous rows. A model reset
+        self._undo.push(
-        # accurately represents this atomic undo command, unlike one
+            DelCommand(
-        # beginRemoveRows() call spanning rows that are not all removed.
+                self._data, rows
-        self.beginResetModel()
-        try:
-            self._undo.push(
-                DelCommand(
-                    self._data, rows
-                )
             )
-        finally:
+        )
-            self.endResetModel()
+
+        self.endRemoveRows()
         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,11 +97,12 @@ class DelCommand(QUndoCommand):
         QUndoCommand.__init__(self)
 
         self._data = data
-        self._rows = sorted(set(rows))
+        self._rows = rows
-        self._bc = [
+
-            self._data.get_i(row)
+        self._bc = []
-            for row in self._rows
+        for row in rows:
-        ]
+            self._bc.append(self._data.get_i(row))
+        self._bc.sort()
 
     def undo(self):
         for el in self._bc:
@@ -119,17 +120,13 @@ class SortCommand(QUndoCommand):
         self._data = data
         self._reverse = _reverse
 
-        # Keep the order of the complete underlying list, including soft
+        self._old = self._data.data
-        # deleted items. ``data`` only exposes visible items and therefore
+        self._indexes = None
-        # 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 item: self._old_positions[id(item)]
+            key=lambda x: self._indexes[ll.index(x)]
         )
 
     def redo(self):
@@ -137,6 +134,14 @@ 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.enable_edges()
+                    lambda n: n.name, self._data.edges()
                 )
             )
 

src/View/DIFAdisTS/Table.py

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

src/View/Geometry/Table.py

@@ -259,9 +259,6 @@ 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,22 +350,14 @@ class GeometryWindow(PamhyrWindow):
             tableview = self.tableView
 
             def fn():
-                return mesher.meshing(self._reach, **data)
+                self._table.meshing(mesher, data, tableview)
-
+            # self._table.meshing(mesher, data, tableview)
             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.enable_edges()
+                    lambda n: n.name, self._data.edges()
                 )
             )
 
@@ -140,30 +140,13 @@ 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: (
+                lambda ica: ica._deleted is False,
-                    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)
 
@@ -238,31 +221,20 @@ 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],
-                        new_value
+                        (self._river.edge(value).id
+                         if self._headers[column] == "reach"
+                         else value
+                         )
                     )
                 )
         except Exception as e:
             logger.info(e)
             logger.debug(traceback.format_exc())
 
-        if self._headers[column] == "reach":
+        self.dataChanged.emit(index, index)
-            rk_index = self.index(
-                row, self._headers.index("rk")
-            )
-            self.dataChanged.emit(index, rk_index)
-        else:
-            self.dataChanged.emit(index, index)
         return True
 
     def add(self, row, parent=QModelIndex()):

src/View/InitialConditionsTemperature/UndoCommand.py

@@ -73,8 +73,6 @@ 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":
@@ -86,19 +84,13 @@ class SetCommandSpec(QUndoCommand):
         elif column == "reach":
             _type = int
 
-        if column == "reach":
+        self._new = _type(new_value)
-            self._new = _type(new_value[0])
-            self._new_rk = float(new_value[1])
-        else:
-            self._new = _type(new_value)
 
     def undo(self):
         if self._column == "name":
             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
@@ -110,8 +102,6 @@ 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,10 +309,3 @@ 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,10 +81,7 @@ 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))
@@ -122,11 +119,6 @@ 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
@@ -135,13 +127,7 @@ class TableModel(PamhyrTableModel):
 
         self._lst = list(
             filter(
-                lambda x: (
+                lambda x: x._deleted is False,
-                    x._deleted is False and
-                    (
-                        x.reach in (None, -1) or
-                        x.reach in enabled_reach_ids
-                    )
-                ),
                 self._lcs_pol_list
             )
         )
@@ -151,18 +137,6 @@ 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()
@@ -196,18 +170,11 @@ 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,
-                        reach.id,
+                        self._data.reach(value).id
-                        min(rks),
-                        max(rks)
                     )
                 )
             elif self._headers[column] == "begin_rk":
@@ -226,13 +193,7 @@ class TableModel(PamhyrTableModel):
             logger.info(e)
             logger.debug(traceback.format_exc())
 
-        if self._headers[column] == "reach":
+        self.dataChanged.emit(index, index)
-            end_index = self.index(
-                row, self._headers.index("end_rk")
-            )
-            self.dataChanged.emit(index, end_index)
-        else:
-            self.dataChanged.emit(index, index)
         return True
 
     def add(self, row, parent=QModelIndex()):

src/View/LateralContributionsAdisTS/UndoCommand.py

@@ -64,30 +64,20 @@ class SetEndCommand(QUndoCommand):
 
 
 class SetReachCommand(QUndoCommand):
-    def __init__(self, lcs, lcs_lst, index, reach, begin_rk, end_rk):
+    def __init__(self, lcs, lcs_lst, index, reach):
         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):
-        contribution = self._lcs_lst[self._index]
+        self._lcs_lst[self._index].reach = self._old
-        contribution.reach = self._old
-        contribution.begin_rk = self._old_begin_rk
-        contribution.end_rk = self._old_end_rk
 
     def redo(self):
-        contribution = self._lcs_lst[self._index]
+        self._lcs_lst[self._index].reach = self._new
-        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,7 +20,6 @@ import logging
 
 from tools import trace, timer
 
-from Modules import Modules
 from View.Tools.PamhyrWindow import PamhyrWindow
 
 from PyQt5.QtGui import (
@@ -188,13 +187,12 @@ class LateralContributionAdisTSWindow(PamhyrWindow):
         data = None
         highlight = None
 
+        tab = "liquid"
+
         if len(rows) > 0:
-            contribution = self._table.get(rows[0])
+            reach_id = self._study.river\
-            reach_id = (
+                       .lateral_contributions_adists.lst[rows[0]]\
-                contribution.reach
+                       .reach
-                if contribution is not None
-                else None
-            )
 
             if reach_id:
                 reach = next(
@@ -203,10 +201,8 @@ class LateralContributionAdisTSWindow(PamhyrWindow):
                         self._study.river.reachs()))
 
                 data = reach.reach
-                highlight = (
+                lc = self._lcs.lst[rows[0]]
-                    contribution.begin_rk,
+                highlight = (lc.begin_rk, lc.end_rk)
-                    contribution.end_rk
-                )
 
                 for delegate in self._delegate_rk:
                     delegate.data = reach
@@ -258,23 +254,13 @@ 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._table.get(row)
+            data = self._lcs.lst[row]
-            if data is None:
-                continue
 
             if self.sub_window_exists(
                 EditLateralContributionAdisTSWindow,

src/View/RunSolver/Window.py

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

src/View/WaitingDialog.py

@@ -47,16 +47,10 @@ class Worker(QObject):
         super(self.__class__, self).__init__(parent)
 
         self._payload_fn = payload_fn
-        self.result = None
-        self.exception = None
 
     def process(self):
-        try:
+        self._payload_fn()
-            self.result = self._payload_fn()
+        self.signalStatus.emit('end')
-        except Exception as exception:
-            self.exception = exception
-        finally:
-            self.signalStatus.emit('end')
 
 
 class WaitingDialog(PamhyrDialog):
@@ -129,14 +123,6 @@ 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,10 +87,7 @@ 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)))
@@ -147,28 +144,8 @@ 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(
+        self._lst = list(filter(lambda wp: wp.type == self._type, self._lst))
-            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:
@@ -262,25 +239,16 @@ 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, edge
+                        self._data, global_row, self._river.edge(value)
                     )
                 )
         except Exception as e:
             logger.info(e)
             logger.debug(traceback.format_exc())
 
-        if self._headers[column] == "reach":
+        self.dataChanged.emit(index, index)
-            end_index = self.index(
-                row, self._headers.index("end_rk")
-            )
-            self.dataChanged.emit(index, end_index)
-        else:
-            self.dataChanged.emit(index, index)
         return True
 
     def add(self, row, parent=QModelIndex()):

src/View/WeatherParameters/UndoCommand.py

@@ -125,26 +125,14 @@ class SetEdgeCommand(QUndoCommand):
 
         self._wps = wps
         self._index = index
-        weather_parameter = self._wps.get(self._index)
+        self._old = self._wps.get(self._index).reach
-        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):
-        weather_parameter = self._wps.get(self._index)
+        self._wps.get(self._index).reach = self._old
-        weather_parameter.reach = self._old
-        weather_parameter.begin_section = self._old_begin
-        weather_parameter.end_section = self._old_end
 
     def redo(self):
-        weather_parameter = self._wps.get(self._index)
+        self._wps.get(self._index).reach = self._new
-        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,10 +439,3 @@ 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()