kp to rk

src/Checker/Adists.py

@@ -29,13 +29,13 @@ _translate = QCoreApplication.translate
 
 logger = logging.getLogger()
 
-class AdistsOutputKpChecker(AbstractModelChecker):
+class AdistsOutputRKChecker(AbstractModelChecker):
     def __init__(self):
-        super(AdistsOutputKpChecker, self).__init__()
+        super(AdistsOutputRKChecker, self).__init__()
 
-        self._name = _translate("Checker", "AdisTS output Kp checker")
+        self._name = _translate("Checker", "AdisTS output RK checker")
         self._description = _translate(
-            "Checker", "Check output Kp"
+            "Checker", "Check output RK"
         )
         self._modules = Modules.OUTPUT_RK
 

src/Meshing/Mage.py

@@ -395,7 +395,7 @@ class MeshingWithMageMailleurTT(AMeshingTool):
             logger.info(
                 f"! {self._exe_path()} " +
                 f"{st_file} {m_file} " +
-                f"update_kp " +
+                f"update_rk " +
                 f"{str(step)} " +
                 f"{limites[0]} {limites[1]} " +
                 f"{directrices[0]} {directrices[1]} " +
@@ -410,7 +410,7 @@ class MeshingWithMageMailleurTT(AMeshingTool):
                         str,
                         [
                             st_file, m_file,
-                            "update_kp", step,
+                            "update_rk", step,
                             limites[0], limites[1],
                             directrices[0], directrices[1],
                             orientation, lm, linear, origin, origin_value

src/Model/D90AdisTS/D90AdisTSSpec.py

@@ -43,8 +43,8 @@ class D90AdisTSSpec(SQLSubModel):
 
         self._name_section = name
         self._reach = None
-        self._start_kp = None
+        self._start_rk = None
-        self._end_kp = None
+        self._end_rk = None
         self._d90 = None
         self._enabled = True
 
@@ -58,8 +58,8 @@ class D90AdisTSSpec(SQLSubModel):
                 d90_default INTEGER NOT NULL,
                 name TEXT NOT NULL,
                 reach INTEGER NOT NULL,
-                start_kp REAL NOT NULL,
+                start_rk REAL NOT NULL,
-                end_kp REAL NOT NULL,
+                end_rk REAL NOT NULL,
                 d90 REAL NOT NULL,
                 enabled BOOLEAN NOT NULL,
                 FOREIGN KEY(d90_default) REFERENCES d90_adists(id),
@@ -83,7 +83,7 @@ class D90AdisTSSpec(SQLSubModel):
         new = []
 
         table = execute(
-            "SELECT id, d90_default, name, reach, start_kp, end_kp, " +
+            "SELECT id, d90_default, name, reach, start_rk, end_rk, " +
             "d90, enabled " +
             "FROM d90_spec " +
             f"WHERE d90_default = {data['d90_default_id']} "
@@ -93,8 +93,8 @@ class D90AdisTSSpec(SQLSubModel):
             id            = row[0]
             name          = row[2]
             reach         = row[3]
-            start_kp      = row[4]
+            start_rk      = row[4]
-            end_kp        = row[5]
+            end_rk        = row[5]
             d90 = row[6]
             enabled       = (row[7] == 1)
 
@@ -105,8 +105,8 @@ class D90AdisTSSpec(SQLSubModel):
             )
 
             new_spec.reach = reach
-            new_spec.start_kp = start_kp
+            new_spec.start_rk = start_rk
-            new_spec.end_kp = end_kp
+            new_spec.end_rk = end_rk
             new_spec.d90 = d90
             new_spec.enabled = enabled
 
@@ -120,14 +120,14 @@ class D90AdisTSSpec(SQLSubModel):
         sql = (
             "INSERT INTO " +
             "d90_spec(id, d90_default, name, reach, " +
-            "start_kp, end_kp, d90, enabled) " +
+            "start_rk, end_rk, d90, enabled) " +
             "VALUES (" +
             f"{self.id}, " +
             f"{d90_default}, " +
             f"'{self._db_format(self._name_section)}', " +
             f"{self._reach}, " +
-            f"{self._start_kp}, " +
+            f"{self._start_rk}, " +
-            f"{self._end_kp}, " +
+            f"{self._end_rk}, " +
             f"{self._d90}, " +
             f"{self._enabled}" +
             ")"
@@ -155,21 +155,21 @@ class D90AdisTSSpec(SQLSubModel):
         self._status.modified()
 
     @property
-    def start_kp(self):
+    def start_rk(self):
-        return self._start_kp
+        return self._start_rk
 
-    @start_kp.setter
+    @start_rk.setter
-    def start_kp(self, start_kp):
+    def start_rk(self, start_rk):
-        self._start_kp = start_kp
+        self._start_rk = start_rk
         self._status.modified()
 
     @property
-    def end_kp(self):
+    def end_rk(self):
-        return self._end_kp
+        return self._end_rk
 
-    @end_kp.setter
+    @end_rk.setter
-    def end_kp(self, end_kp):
+    def end_rk(self, end_rk):
-        self._end_kp = end_kp
+        self._end_rk = end_rk
         self._status.modified()
 
     @property

src/Model/DIFAdisTS/DIFAdisTSSpec.py

@@ -43,8 +43,8 @@ class DIFAdisTSSpec(SQLSubModel):
 
         self._method = method
         self._reach = None
-        self._start_kp = None
+        self._start_rk = None
-        self._end_kp = None
+        self._end_rk = None
         self._dif = None
         self._b = None
         self._c = None
@@ -60,8 +60,8 @@ class DIFAdisTSSpec(SQLSubModel):
                 dif_default INTEGER NOT NULL,
                 method TEXT NOT NULL,
                 reach INTEGER NOT NULL,
-                start_kp REAL NOT NULL,
+                start_rk REAL NOT NULL,
-                end_kp REAL NOT NULL,
+                end_rk REAL NOT NULL,
                 dif REAL NOT NULL,
                 b REAL,
                 c REAL,
@@ -87,7 +87,7 @@ class DIFAdisTSSpec(SQLSubModel):
         new = []
 
         table = execute(
-            "SELECT id, dif_default, method, reach, start_kp, end_kp, " +
+            "SELECT id, dif_default, method, reach, start_rk, end_rk, " +
             "dif, b, c, enabled " +
             "FROM dif_spec " +
             f"WHERE dif_default = {data['dif_default_id']} "
@@ -97,8 +97,8 @@ class DIFAdisTSSpec(SQLSubModel):
             id            = row[0]
             method          = row[2]
             reach         = row[3]
-            start_kp      = row[4]
+            start_rk      = row[4]
-            end_kp        = row[5]
+            end_rk        = row[5]
             dif = row[6]
             b = row[7]
             c = row[8]
@@ -111,8 +111,8 @@ class DIFAdisTSSpec(SQLSubModel):
             )
 
             new_spec.reach = reach
-            new_spec.start_kp = start_kp
+            new_spec.start_rk = start_rk
-            new_spec.end_kp = end_kp
+            new_spec.end_rk = end_rk
             new_spec.dif = dif
             new_spec.b = b
             new_spec.c = c
@@ -128,14 +128,14 @@ class DIFAdisTSSpec(SQLSubModel):
         sql = (
             "INSERT INTO " +
             "dif_spec(id, dif_default, method, reach, " +
-            "start_kp, end_kp, dif, b, c, enabled) " +
+            "start_rk, end_rk, dif, b, c, enabled) " +
             "VALUES (" +
             f"{self.id}, " +
             f"{dif_default}, " +
             f"'{self._db_format(self._method)}', " +
             f"{self._reach}, " +
-            f"{self._start_kp}, " +
+            f"{self._start_rk}, " +
-            f"{self._end_kp}, " +
+            f"{self._end_rk}, " +
             f"{self._dif}, " +
             f"{self._b}, " +
             f"{self._c}, " +
@@ -165,21 +165,21 @@ class DIFAdisTSSpec(SQLSubModel):
         self._status.modified()
 
     @property
-    def start_kp(self):
+    def start_rk(self):
-        return self._start_kp
+        return self._start_rk
 
-    @start_kp.setter
+    @start_rk.setter
-    def start_kp(self, start_kp):
+    def start_rk(self, start_rk):
-        self._start_kp = start_kp
+        self._start_rk = start_rk
         self._status.modified()
 
     @property
-    def end_kp(self):
+    def end_rk(self):
-        return self._end_kp
+        return self._end_rk
 
-    @end_kp.setter
+    @end_rk.setter
-    def end_kp(self, end_kp):
+    def end_rk(self, end_rk):
-        self._end_kp = end_kp
+        self._end_rk = end_rk
         self._status.modified()
 
     @property

src/Model/Friction/Friction.py

@@ -75,8 +75,8 @@ class Friction(SQLSubModel):
         if major == minor == "0":
             if int(release) < 11:
                 execute("ALTER TABLE friction " +
-                        "RENAME COLUMN begin_kp TO begin_rk")
+                        "RENAME COLUMN begin_rk TO begin_rk")
-                execute("ALTER TABLE friction RENAME COLUMN end_kp TO end_rk")
+                execute("ALTER TABLE friction RENAME COLUMN end_rk TO end_rk")
 
         return True
 

src/Model/Geometry/ProfileXYZ.py

@@ -108,7 +108,7 @@ class ProfileXYZ(Profile, SQLSubModel):
                 execute(
                     """
                     ALTER TABLE geometry_profileXYZ
-                    RENAME COLUMN kp TO rk
+                    RENAME COLUMN rk TO rk
                     """
                 )
 

src/Model/HydraulicStructures/HydraulicStructures.py

@@ -94,13 +94,13 @@ class HydraulicStructure(SQLSubModel):
                 execute(
                     """
                     ALTER TABLE hydraulic_structures
-                    RENAME COLUMN input_kp TO input_rk
+                    RENAME COLUMN input_rk TO input_rk
                     """
                 )
                 execute(
                     """
                     ALTER TABLE hydraulic_structures
-                    RENAME COLUMN output_kp TO output_rk
+                    RENAME COLUMN output_rk TO output_rk
                     """
                 )
 

src/Model/InitialConditions/InitialConditions.py

@@ -80,7 +80,7 @@ class Data(SQLSubModel):
         if major == minor == "0":
             if int(release) < 11:
                 execute(
-                    "ALTER TABLE initial_conditions RENAME COLUMN kp TO rk"
+                    "ALTER TABLE initial_conditions RENAME COLUMN rk TO rk"
                 )
 
         return cls._update_submodel(execute, version)

src/Model/InitialConditionsAdisTS/InitialConditionsAdisTSSpec.py

@@ -43,8 +43,8 @@ class ICAdisTSSpec(SQLSubModel):
 
         self._name_section = name
         self._reach = None
-        self._start_kp = None
+        self._start_rk = None
-        self._end_kp = None
+        self._end_rk = None
         self._concentration = None
         self._eg = None
         self._em = None
@@ -62,8 +62,8 @@ class ICAdisTSSpec(SQLSubModel):
                 ic_default INTEGER NOT NULL,
                 name TEXT NOT NULL,
                 reach INTEGER NOT NULL,
-                start_kp REAL NOT NULL,
+                start_rk REAL NOT NULL,
-                end_kp REAL NOT NULL,
+                end_rk REAL NOT NULL,
                 concentration REAL NOT NULL,
                 eg REAL NOT NULL,
                 em REAL NOT NULL,
@@ -91,7 +91,7 @@ class ICAdisTSSpec(SQLSubModel):
         new = []
 
         table = execute(
-            "SELECT id, ic_default, name, reach, start_kp, end_kp, " +
+            "SELECT id, ic_default, name, reach, start_rk, end_rk, " +
             "concentration, eg, em, ed, rate, enabled " +
             "FROM initial_conditions_spec " +
             f"WHERE ic_default = {data['ic_default_id']} "
@@ -101,8 +101,8 @@ class ICAdisTSSpec(SQLSubModel):
             id            = row[0]
             name          = row[2]
             reach         = row[3]
-            start_kp      = row[4]
+            start_rk      = row[4]
-            end_kp        = row[5]
+            end_rk        = row[5]
             concentration = row[6]
             eg            = row[7]
             em            = row[8]
@@ -110,7 +110,7 @@ class ICAdisTSSpec(SQLSubModel):
             rate          = row[10]
             enabled       = (row[11] == 1)
 
-            #new_spec = [name, reach, start_kp, end_kp, concentration, eg, em, ed, rate, enabled]
+            #new_spec = [name, reach, start_rk, end_rk, concentration, eg, em, ed, rate, enabled]
 
             new_spec = cls(
                 id=id,
@@ -119,8 +119,8 @@ class ICAdisTSSpec(SQLSubModel):
             )
 
             new_spec.reach = reach
-            new_spec.start_kp = start_kp
+            new_spec.start_rk = start_rk
-            new_spec.end_kp = end_kp
+            new_spec.end_rk = end_rk
             new_spec.concentration = concentration
             new_spec.eg = eg
             new_spec.em = em
@@ -138,14 +138,14 @@ class ICAdisTSSpec(SQLSubModel):
         sql = (
             "INSERT INTO " +
             "initial_conditions_spec(id, ic_default, name, reach, " +
-            "start_kp, end_kp, concentration, eg, em, ed, rate, enabled) " +
+            "start_rk, end_rk, concentration, eg, em, ed, rate, enabled) " +
             "VALUES (" +
             f"{self.id}, " +
             f"{ic_default}, " +
             f"'{self._db_format(self._name_section)}', " +
             f"{self._reach}, " +
-            f"{self._start_kp}, " +
+            f"{self._start_rk}, " +
-            f"{self._end_kp}, " +
+            f"{self._end_rk}, " +
             f"{self._concentration}, " +
             f"{self._eg}, " +
             f"{self._em}, " +
@@ -177,21 +177,21 @@ class ICAdisTSSpec(SQLSubModel):
         self._status.modified()
 
     @property
-    def start_kp(self):
+    def start_rk(self):
-        return self._start_kp
+        return self._start_rk
 
-    @start_kp.setter
+    @start_rk.setter
-    def start_kp(self, start_kp):
+    def start_rk(self, start_rk):
-        self._start_kp = start_kp
+        self._start_rk = start_rk
         self._status.modified()
 
     @property
-    def end_kp(self):
+    def end_rk(self):
-        return self._end_kp
+        return self._end_rk
 
-    @end_kp.setter
+    @end_rk.setter
-    def end_kp(self, end_kp):
+    def end_rk(self, end_rk):
-        self._end_kp = end_kp
+        self._end_rk = end_rk
         self._status.modified()
 
     @property

src/Model/LateralContribution/LateralContribution.py

@@ -93,13 +93,13 @@ class LateralContribution(SQLSubModel):
                 execute(
                     """
                     ALTER TABLE lateral_contribution
-                    RENAME COLUMN begin_kp TO begin_rk
+                    RENAME COLUMN begin_rk TO begin_rk
                     """
                 )
                 execute(
                     """
                     ALTER TABLE lateral_contribution
-                    RENAME COLUMN end_kp TO end_rk
+                    RENAME COLUMN end_rk TO end_rk
                     """
                 )
 

src/Model/LateralContributionsAdisTS/LateralContributionAdisTS.py

@@ -46,8 +46,8 @@ class LateralContributionAdisTS(SQLSubModel):
 
         self._pollutant = pollutant
         self._edge = None
-        self._begin_kp = 0.0
+        self._begin_rk = 0.0
-        self._end_kp = 0.0
+        self._end_rk = 0.0
         self._data = []
         self._header = ["time", "rate"]
         self._types = [self.time_convert, float]
@@ -62,8 +62,8 @@ class LateralContributionAdisTS(SQLSubModel):
             id INTEGER NOT NULL PRIMARY KEY,
             pollutant INTEGER NOT NULL,
             edge INTEGER NOT NULL,
-            begin_kp REAL NOT NULL,
+            begin_rk REAL NOT NULL,
-            end_kp REAL NOT NULL,
+            end_rk REAL NOT NULL,
             FOREIGN KEY(pollutant) REFERENCES Pollutants(id),
             FOREIGN KEY(edge) REFERENCES river_reach(id)
           )
@@ -90,7 +90,7 @@ class LateralContributionAdisTS(SQLSubModel):
         new = []
 
         table = execute(
-            "SELECT id, pollutant, edge, begin_kp, end_kp " +
+            "SELECT id, pollutant, edge, begin_rk, end_rk " +
             "FROM lateral_contribution_adists"
         )
 
@@ -103,8 +103,8 @@ class LateralContributionAdisTS(SQLSubModel):
                 )
 
                 lc.edge = row[2]
-                lc.begin_kp = row[3]
+                lc.begin_rk = row[3]
-                lc.end_kp = row[4]
+                lc.end_rk = row[4]
 
                 values = execute(
                     "SELECT data0, data1 FROM lateral_contribution_data_adists " +
@@ -129,10 +129,10 @@ class LateralContributionAdisTS(SQLSubModel):
 
         sql = (
             "INSERT INTO " +
-            "lateral_contribution_adists(id, pollutant, edge, begin_kp, end_kp) " +
+            "lateral_contribution_adists(id, pollutant, edge, begin_rk, end_rk) " +
             "VALUES (" +
             f"{self.id}, {self._pollutant}, {self.edge}, " +
-            f"{self._begin_kp}, {self._end_kp}" +
+            f"{self._begin_rk}, {self._end_rk}" +
             ")"
         )
         execute(sql)
@@ -196,20 +196,20 @@ class LateralContributionAdisTS(SQLSubModel):
         return self._data.copy()
 
     @property
-    def begin_kp(self):
+    def begin_rk(self):
-        return self._begin_kp
+        return self._begin_rk
 
-    @begin_kp.setter
+    @begin_rk.setter
-    def begin_kp(self, begin_kp):
+    def begin_rk(self, begin_rk):
-        self._begin_kp = begin_kp
+        self._begin_rk = begin_rk
         self._status.modified()
 
     @property
-    def end_kp(self):
+    def end_rk(self):
-        return self._end_kp
+        return self._end_rk
 
-    @end_kp.setter
+    @end_rk.setter
-    def end_kp(self, end_kp):
+    def end_rk(self, end_rk):
-        self._end_kp = end_kp
+        self._end_rk = end_rk
         self._status.modified()
 

src/Model/OutputRKAdists/OutputRKAdists.py

@@ -1,4 +1,4 @@
-# OutputKpAdists.py -- Pamhyr
+# OutputRKAdists.py -- Pamhyr
 # Copyright (C) 2023-2024  INRAE
 #
 # This program is free software: you can redistribute it and/or modify
@@ -30,27 +30,27 @@ from Model.Except import NotImplementedMethodeError
 
 logger = logging.getLogger()
 
-class OutputKpAdists(SQLSubModel):
+class OutputRKAdists(SQLSubModel):
     _sub_classes = []
     _id_cnt = 0
 
-    def __init__(self, id: int = -1, reach = None, kp = None, title: str = "",  status=None):
+    def __init__(self, id: int = -1, reach = None, rk = None, title: str = "",  status=None):
-        super(OutputKpAdists, self).__init__()
+        super(OutputRKAdists, self).__init__()
 
         self._status = status
 
         if id == -1:
-            self.id = OutputKpAdists._id_cnt
+            self.id = OutputRKAdists._id_cnt
         else:
             self.id = id
 
         self._reach = reach
-        self._kp = kp
+        self._rk = rk
         self._title = str(title)
         self._enabled = True
 
-        OutputKpAdists._id_cnt = max(
+        OutputRKAdists._id_cnt = max(
-            OutputKpAdists._id_cnt + 1, self.id)
+            OutputRKAdists._id_cnt + 1, self.id)
 
     @property
     def reach(self):
@@ -62,12 +62,12 @@ class OutputKpAdists(SQLSubModel):
         self._status.modified()
 
     @property
-    def kp(self):
+    def rk(self):
-        return self._kp
+        return self._rk
 
-    @kp.setter
+    @rk.setter
-    def kp(self, profile_id):
+    def rk(self, profile_id):
-        self._kp = profile_id
+        self._rk = profile_id
         self._status.modified()
 
     @property
@@ -84,10 +84,10 @@ class OutputKpAdists(SQLSubModel):
     def _db_create(cls, execute):
 
         sql = (
-            "CREATE TABLE OutputKpAdists(" +
+            "CREATE TABLE OutputRKAdists(" +
             "id INTEGER NOT NULL PRIMARY KEY, " +
             "reach INTEGER NOT NULL, " +
-            "kp REAL NOT NULL, " +
+            "rk REAL NOT NULL, " +
             "title TEXT NOT NULL, " +
             "FOREIGN KEY(reach) REFERENCES river_reach(id)" +
             ")"
@@ -110,20 +110,20 @@ class OutputKpAdists(SQLSubModel):
         status  = data["status"]
 
         table = execute(
-            "SELECT id, reach, kp, title " +
+            "SELECT id, reach, rk, title " +
-            f"FROM OutputKpAdists"
+            f"FROM OutputRKAdists"
         )
 
         if table is not None:
             for row in table:
                 id       = row[0]
                 id_reach = row[1]
-                id_kp    = row[2]
+                id_rk    = row[2]
                 title    = row[3]
 
                 new_output = cls(
                     id=id, reach=id_reach,
-                    kp=id_kp, title=title,
+                    rk=id_rk, title=title,
                     status=status
                 )
 
@@ -133,13 +133,13 @@ class OutputKpAdists(SQLSubModel):
 
     def _db_save(self, execute, data=None):
 
-        execute(f"DELETE FROM OutputKpAdists WHERE id = {self.id}")
+        execute(f"DELETE FROM OutputRKAdists WHERE id = {self.id}")
 
         sql = (
             "INSERT INTO " +
-            "OutputKpAdists(id, reach, kp, title) " +
+            "OutputRKAdists(id, reach, rk, title) " +
             "VALUES (" +
-            f"{self.id}, {self._reach}, {self._kp}, " +
+            f"{self.id}, {self._reach}, {self._rk}, " +
             f"'{self._db_format(self._title)}'" +
             ")"
         )

src/Model/OutputRKAdists/OutputRKListAdists.py

@@ -1,4 +1,4 @@
-# OutputKpListAdists.py -- Pamhyr
+# OutputRKListAdists.py -- Pamhyr
 # Copyright (C) 2024  INRAE
 #
 # This program is free software: you can redistribute it and/or modify
@@ -20,17 +20,17 @@ from tools import trace, timer
 
 from Model.Except import NotImplementedMethodeError
 from Model.Tools.PamhyrList import PamhyrModelList
-from Model.OutputKpAdists.OutputKpAdists import OutputKpAdists
+from Model.OutputRKAdists.OutputRKAdists import OutputRKAdists
 
 
-class OutputKpAdistsList(PamhyrModelList):
+class OutputRKAdistsList(PamhyrModelList):
-    _sub_classes = [OutputKpAdists]
+    _sub_classes = [OutputRKAdists]
 
     @classmethod
     def _db_load(cls, execute, data=None):
         new = cls(status=data["status"])
 
-        new._lst = OutputKpAdists._db_load(execute, data)
+        new._lst = OutputRKAdists._db_load(execute, data)
 
         return new
 
@@ -38,7 +38,7 @@ class OutputKpAdistsList(PamhyrModelList):
         ok = True
 
         # Delete previous data
-        execute("DELETE FROM OutputKpAdists")
+        execute("DELETE FROM OutputRKAdists")
 
         for sl in self._lst:
             ok &= sl._db_save(execute, data)
@@ -46,11 +46,11 @@ class OutputKpAdistsList(PamhyrModelList):
         return ok
 
     @property
-    def OutputKp_List(self):
+    def OutputRK_List(self):
         return self.lst
 
     def new(self, lst, index):
-        n = OutputKpAdists(status=self._status)
+        n = OutputRKAdists(status=self._status)
         self._lst.insert(index, n)
         self._status.modified()
         return n

src/Model/Results/River/RiverAdisTS.py

@@ -35,8 +35,8 @@ class Profile(object):
         return self._profile.name
 
     @property
-    def kp(self):
+    def rk(self):
-        return self._profile.kp
+        return self._profile.rk
 
     @property
     def geometry(self):

src/Model/River.py

@@ -45,7 +45,7 @@ from Model.REPLine.REPLineList import REPLineList
 
 from Solver.Solvers import solver_type_list
 
-from Model.OutputKpAdists.OutputKpListAdists import OutputKpAdistsList
+from Model.OutputRKAdists.OutputRKListAdists import OutputRKAdistsList
 from Model.Pollutants.PollutantsList import PollutantsList
 from Model.InitialConditionsAdisTS.InitialConditionsAdisTSList import InitialConditionsAdisTSList
 from Model.BoundaryConditionsAdisTS.BoundaryConditionsAdisTSList import BoundaryConditionsAdisTSList
@@ -236,7 +236,7 @@ class River(Graph, SQLSubModel):
         HydraulicStructureList,
         AddFileList,
         REPLineList,
-        OutputKpAdistsList,
+        OutputRKAdistsList,
         PollutantsList,
         InitialConditionsAdisTSList,
         BoundaryConditionsAdisTSList,
@@ -266,7 +266,7 @@ class River(Graph, SQLSubModel):
         )
         self._additional_files = AddFileList(status=self._status)
         self._rep_lines = REPLineList(status=self._status)
-        self._Output_kp_adists = OutputKpAdistsList(status=self._status)
+        self._Output_rk_adists = OutputRKAdistsList(status=self._status)
         self._Pollutants = PollutantsList(status=self._status)
         self._InitialConditionsAdisTS = InitialConditionsAdisTSList(status=self._status)
         self._BoundaryConditionsAdisTS = BoundaryConditionsAdisTSList(status=self._status)
@@ -347,7 +347,7 @@ class River(Graph, SQLSubModel):
         )
         new._rep_lines = REPLineList._db_load(execute, data)
 
-        new._Output_kp_adists = OutputKpAdistsList._db_load(
+        new._Output_rk_adists = OutputRKAdistsList._db_load(
             execute, data
         )
 
@@ -382,7 +382,7 @@ class River(Graph, SQLSubModel):
         for solver in self._parameters:
             objs.append(self._parameters[solver])
 
-        objs.append(self._Output_kp_adists)
+        objs.append(self._Output_rk_adists)
         objs.append(self._Pollutants)
         objs.append(self._InitialConditionsAdisTS)
         objs.append(self._BoundaryConditionsAdisTS)
@@ -513,8 +513,8 @@ Last export at: @date."""
         return self._parameters
 
     @property
-    def Output_kp_adists(self):
+    def Output_rk_adists(self):
-        return self._Output_kp_adists
+        return self._Output_rk_adists
 
     @property
     def Pollutants(self):

src/Solver/AdisTS.py

@@ -37,7 +37,7 @@ from Model.Results.ResultsAdisTS import Results
 from Model.Results.River.River import River, Reach, Profile
 
 from Checker.Adists import (
-    AdistsOutputKpChecker,
+    AdistsOutputRKChecker,
 )
 
 logger = logging.getLogger()
@@ -88,7 +88,7 @@ class AdisTS(CommandLineSolver):
     @classmethod
     def checkers(cls):
         lst = [
-            AdistsOutputKpChecker(),
+            AdistsOutputRKChecker(),
         ]
 
         return lst
@@ -254,7 +254,7 @@ class AdisTSlc(AdisTS):
         with adists_file_open(os.path.join(repertory, f"{POL_name}.ALD"), "w+") as f:
             for LC in POL_LC:
                 reach_name = next(filter(lambda edge: edge.id == LC.edge, study.river.edges())).name
-                f.write(f"${reach_name} {LC.begin_kp} {LC.end_kp}\n")
+                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")
 
@@ -305,7 +305,7 @@ class AdisTSlc(AdisTS):
     def _export_ICs_AdisTS_Spec(self, study, pol_ics_spec_data, f, qlog, name="0"):
 
         for ic_spec in pol_ics_spec_data:
-            f.write(f"{ic_spec.name} = {ic_spec.reach} {ic_spec.start_kp} {ic_spec.end_kp} " +
+            f.write(f"{ic_spec.name} = {ic_spec.reach} {ic_spec.start_rk} {ic_spec.end_rk} " +
                     f"{ic_spec.concentration} {ic_spec.eg} {ic_spec.em} {ic_spec.ed} {ic_spec.rate}")
 
         return True
@@ -341,8 +341,8 @@ class AdisTSlc(AdisTS):
     def _export_d90_spec(self, study, d90_spec_data, f, qlog, name="0"):
 
         for d90_spec in d90_spec_data:
-            if (d90_spec.name is None) or (d90_spec.reach is None) or (d90_spec.start_kp is None) or \
+            if (d90_spec.name is None) or (d90_spec.reach is None) or (d90_spec.start_rk is None) or \
-                (d90_spec.end_kp is None) or (d90_spec.d90 is None):
+                (d90_spec.end_rk is None) or (d90_spec.d90 is None):
                 return
 
             edges = study.river.enable_edges()
@@ -354,7 +354,7 @@ class AdisTSlc(AdisTS):
             if id_reach not in id_edges:
                 return
 
-            f.write(f"{d90_spec.name} = {id_reach} {d90_spec.start_kp} {d90_spec.end_kp} {d90_spec.d90}\n")
+            f.write(f"{d90_spec.name} = {id_reach} {d90_spec.start_rk} {d90_spec.end_rk} {d90_spec.d90}\n")
 
     def _export_DIF(self, study, repertory, qlog=None, name="0"):
 
@@ -383,8 +383,8 @@ class AdisTSlc(AdisTS):
     def _export_dif_spec(self, study, dif_spec_data, f, qlog, name="0"):
 
         for dif_spec in dif_spec_data:
-            if (dif_spec.reach is None) or (dif_spec.start_kp is None) or \
+            if (dif_spec.reach is None) or (dif_spec.start_rk is None) or \
-                (dif_spec.end_kp is None) or (dif_spec.dif is None) or (dif_spec.b is None) or (dif_spec.c is None):
+                (dif_spec.end_rk is None) or (dif_spec.dif is None) or (dif_spec.b is None) or (dif_spec.c is None):
                 return
 
             edges = study.river.enable_edges()
@@ -397,9 +397,9 @@ class AdisTSlc(AdisTS):
                 return
 
             if dif_spec.method != "generique":
-                f.write(f"{dif_spec.method} = {id_reach} {dif_spec.start_kp} {dif_spec.end_kp} {dif_spec.dif}\n")
+                f.write(f"{dif_spec.method} = {id_reach} {dif_spec.start_rk} {dif_spec.end_rk} {dif_spec.dif}\n")
             else:
-                f.write(f"{dif_spec.method} = {id_reach} {dif_spec.start_kp} {dif_spec.end_kp} {dif_spec.dif}" +
+                f.write(f"{dif_spec.method} = {id_reach} {dif_spec.start_rk} {dif_spec.end_rk} {dif_spec.dif}" +
                 f"{dif_spec.b} {dif_spec.c}\n")
 
     def _export_NUM(self, study, repertory, qlog=None, name="0"):
@@ -435,29 +435,29 @@ class AdisTSlc(AdisTS):
                 if name != "command_line_arguments":
                     f.write(f"{dict_names[name]} = {value}\n")
 
-            outputkps = study.river.Output_kp_adists.OutputKp_List
+            outputrks = study.river.Output_rk_adists.OutputRK_List
 
-            for outputkp in outputkps:
+            for outputrk in outputrks:
-                self._export_outputkp(study, outputkp, f, qlog)
+                self._export_outputrk(study, outputrk, f, qlog)
 
         return files
 
-    def _export_outputkp(self, study, outputkp, f, qlog, name="0"):
+    def _export_outputrk(self, study, outputrk, f, qlog, name="0"):
-        if (outputkp.reach is None) or (outputkp.kp is None) or (outputkp.title is None):
+        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 = outputkp.reach
+        id_reach = outputrk.reach
-        kp = outputkp.kp
+        rk = outputrk.rk
-        title = outputkp.title
+        title = outputrk.title
 
         if id_reach not in id_edges:
             return
 
-        f.write(f"output = {id_reach} {kp} {title}\n")
+        f.write(f"output = {id_reach} {rk} {title}\n")
 
     @timer
     def read_bin(self, study, repertory, results, qlog=None, name="0"):

src/View/D90AdisTS/Table.py

@@ -58,7 +58,7 @@ class ComboBoxDelegate(QItemDelegate):
         self.editor = QComboBox(parent)
 
         val = []
-        if self._mode == "kp":
+        if self._mode == "rk":
             reach_id = self._ic_spec_lst[index.row()].reach
 
             reach = next(filter(lambda edge: edge.id == reach_id, self._data.edges()))
@@ -66,7 +66,7 @@ class ComboBoxDelegate(QItemDelegate):
             if reach_id is not None:
                 val = list(
                     map(
-                        lambda kp: str(kp), reach.reach.get_kp()
+                        lambda rk: str(rk), reach.reach.get_rk()
                     )
                 )
         else:
@@ -137,13 +137,13 @@ class D90TableModel(PamhyrTableModel):
             if n is None:
                 return self._trad['not_associated']
             return next(filter(lambda edge: edge.id == n, self._river.edges())).name
-        elif self._headers[column] is "start_kp":
+        elif self._headers[column] is "start_rk":
-            n = self._lst[row].start_kp
+            n = self._lst[row].start_rk
             if n is None:
                 return self._trad['not_associated']
             return n
-        elif self._headers[column] is "end_kp":
+        elif self._headers[column] is "end_rk":
-            n = self._lst[row].end_kp
+            n = self._lst[row].end_rk
             if n is None:
                 return self._trad['not_associated']
             return n

src/View/D90AdisTS/UndoCommand.py

@@ -70,10 +70,10 @@ class SetCommandSpec(QUndoCommand):
             self._old = self._data[self._row].name
         elif self._column == "reach":
             self._old = self._data[self._row].reach
-        elif self._column == "start_kp":
+        elif self._column == "start_rk":
-            self._old = self._data[self._row].start_kp
+            self._old = self._data[self._row].start_rk
-        elif self._column == "end_kp":
+        elif self._column == "end_rk":
-            self._old = self._data[self._row].end_kp
+            self._old = self._data[self._row].end_rk
         elif self._column == "d90":
             self._old = self._data[self._row].d90
 
@@ -90,10 +90,10 @@ class SetCommandSpec(QUndoCommand):
             self._data[self._row].name = self._old
         elif self._column == "reach":
             self._data[self._row].reach = self._old
-        elif self._column == "start_kp":
+        elif self._column == "start_rk":
-            self._data[self._row].start_kp = self._old
+            self._data[self._row].start_rk = self._old
-        elif self._column == "end_kp":
+        elif self._column == "end_rk":
-            self._data[self._row].end_kp = self._old
+            self._data[self._row].end_rk = self._old
         elif self._column == "d90":
             self._data[self._row].d90 = self._old
 
@@ -102,10 +102,10 @@ class SetCommandSpec(QUndoCommand):
             self._data[self._row].name = self._new
         elif self._column == "reach":
             self._data[self._row].reach = self._new
-        elif self._column == "start_kp":
+        elif self._column == "start_rk":
-            self._data[self._row].start_kp = self._new
+            self._data[self._row].start_rk = self._new
-        elif self._column == "end_kp":
+        elif self._column == "end_rk":
-            self._data[self._row].end_kp = self._new
+            self._data[self._row].end_rk = self._new
         elif self._column == "d90":
             self._data[self._row].d90 = self._new
 

src/View/D90AdisTS/Window.py

@@ -140,22 +140,22 @@ class D90AdisTSWindow(PamhyrWindow):
             parent=self,
             mode="reaches"
         )
-        self._delegate_kp = ComboBoxDelegate(
+        self._delegate_rk = ComboBoxDelegate(
             trad=self._trad,
             data=self._study.river,
             ic_spec_lst=self._data[0]._data,
             parent=self,
-            mode="kp"
+            mode="rk"
         )
 
         self._table_spec = D90TableModel(
             table_view=self.table_spec,
             table_headers=self._trad.get_dict("table_headers_spec"),
-            editable_headers=["name", "reach", "start_kp", "end_kp", "d90"],
+            editable_headers=["name", "reach", "start_rk", "end_rk", "d90"],
             delegates={
                 "reach": self._delegate_reach,
-                "start_kp": self._delegate_kp,
+                "start_rk": self._delegate_rk,
-                "end_kp": self._delegate_kp
+                "end_rk": self._delegate_rk
             },
             data=self._data[0],
             undo=self._undo_stack,
@@ -226,7 +226,7 @@ class D90AdisTSWindow(PamhyrWindow):
                 lambda eic: list(
                     map(
                         lambda k: eic[1][k],
-                        ["kp", "discharge", "elevation"]
+                        ["rk", "discharge", "elevation"]
                     )
                 ),
                 filter(

src/View/D90AdisTS/translate.py

@@ -30,7 +30,7 @@ class D90AdisTSTranslate(MainTranslate):
         self._dict["D90 AdisTS"] = _translate(
             "D90AdisTS", "D90 AdisTS")
 
-        self._dict["kp"] = self._dict["unit_rk"]
+        self._dict["rk"] = self._dict["unit_rk"]
 
         self._sub_dict["table_headers"] = {
             "name": self._dict["name"],
@@ -40,7 +40,7 @@ class D90AdisTSTranslate(MainTranslate):
         self._sub_dict["table_headers_spec"] = {
             "name": self._dict["name"],
             "reach": self._dict["reach"],
-            "start_kp": _translate("Unit", "Start_RK (m)"),
+            "start_rk": _translate("Unit", "Start_RK (m)"),
-            "end_kp": _translate("Unit", "End_RK (m)"),
+            "end_rk": _translate("Unit", "End_RK (m)"),
             "d90": _translate("Unit", "D90"),
         }

src/View/DIFAdisTS/Table.py

@@ -58,7 +58,7 @@ class ComboBoxDelegate(QItemDelegate):
         self.editor = QComboBox(parent)
 
         val = []
-        if self._mode == "kp":
+        if self._mode == "rk":
             reach_id = self._ic_spec_lst[index.row()].reach
 
             reach = next(filter(lambda edge: edge.id == reach_id, self._data.edges()))
@@ -66,7 +66,7 @@ class ComboBoxDelegate(QItemDelegate):
             if reach_id is not None:
                 val = list(
                     map(
-                        lambda kp: str(kp), reach.reach.get_kp()
+                        lambda rk: str(rk), reach.reach.get_rk()
                     )
                 )
         elif self._mode == "method":
@@ -139,13 +139,13 @@ class DIFTableModel(PamhyrTableModel):
             if n is None:
                 return self._trad['not_associated']
             return next(filter(lambda edge: edge.id == n, self._river.edges())).name
-        elif self._headers[column] is "start_kp":
+        elif self._headers[column] is "start_rk":
-            n = self._lst[row].start_kp
+            n = self._lst[row].start_rk
             if n is None:
                 return self._trad['not_associated']
             return n
-        elif self._headers[column] is "end_kp":
+        elif self._headers[column] is "end_rk":
-            n = self._lst[row].end_kp
+            n = self._lst[row].end_rk
             if n is None:
                 return self._trad['not_associated']
             return n

src/View/DIFAdisTS/UndoCommand.py

@@ -82,10 +82,10 @@ class SetCommandSpec(QUndoCommand):
             self._old = self._data[self._row].method
         elif self._column == "reach":
             self._old = self._data[self._row].reach
-        elif self._column == "start_kp":
+        elif self._column == "start_rk":
-            self._old = self._data[self._row].start_kp
+            self._old = self._data[self._row].start_rk
-        elif self._column == "end_kp":
+        elif self._column == "end_rk":
-            self._old = self._data[self._row].end_kp
+            self._old = self._data[self._row].end_rk
         elif self._column == "dif":
             self._old = self._data[self._row].dif
         elif self._column == "b":
@@ -106,10 +106,10 @@ class SetCommandSpec(QUndoCommand):
             self._data[self._row].method = self._old
         elif self._column == "reach":
             self._data[self._row].reach = self._old
-        elif self._column == "start_kp":
+        elif self._column == "start_rk":
-            self._data[self._row].start_kp = self._old
+            self._data[self._row].start_rk = self._old
-        elif self._column == "end_kp":
+        elif self._column == "end_rk":
-            self._data[self._row].end_kp = self._old
+            self._data[self._row].end_rk = self._old
         elif self._column == "dif":
             self._data[self._row].dif = self._old
         elif self._column == "b":
@@ -122,10 +122,10 @@ class SetCommandSpec(QUndoCommand):
             self._data[self._row].method = self._new
         elif self._column == "reach":
             self._data[self._row].reach = self._new
-        elif self._column == "start_kp":
+        elif self._column == "start_rk":
-            self._data[self._row].start_kp = self._new
+            self._data[self._row].start_rk = self._new
-        elif self._column == "end_kp":
+        elif self._column == "end_rk":
-            self._data[self._row].end_kp = self._new
+            self._data[self._row].end_rk = self._new
         elif self._column == "dif":
             self._data[self._row].dif = self._new
         elif self._column == "b":

src/View/DIFAdisTS/Window.py

@@ -146,23 +146,23 @@ class DIFAdisTSWindow(PamhyrWindow):
             parent=self,
             mode="reaches"
         )
-        self._delegate_kp = ComboBoxDelegate(
+        self._delegate_rk = ComboBoxDelegate(
             trad=self._trad,
             data=self._study.river,
             ic_spec_lst=self._data[0]._data,
             parent=self,
-            mode="kp"
+            mode="rk"
         )
 
         self._table_spec = DIFTableModel(
             table_view=self.table_spec,
             table_headers=self._trad.get_dict("table_headers_spec"),
-            editable_headers=["method", "reach", "start_kp", "end_kp", "dif", "b", "c"],
+            editable_headers=["method", "reach", "start_rk", "end_rk", "dif", "b", "c"],
             delegates={
                 "method": self._delegate_method,
                 "reach": self._delegate_reach,
-                "start_kp": self._delegate_kp,
+                "start_rk": self._delegate_rk,
-                "end_kp": self._delegate_kp
+                "end_rk": self._delegate_rk
             },
             data=self._data[0],
             undo=self._undo_stack,
@@ -233,7 +233,7 @@ class DIFAdisTSWindow(PamhyrWindow):
                 lambda eic: list(
                     map(
                         lambda k: eic[1][k],
-                        ["kp", "discharge", "elevation"]
+                        ["rk", "discharge", "elevation"]
                     )
                 ),
                 filter(

src/View/DIFAdisTS/translate.py

@@ -30,7 +30,7 @@ class DIFAdisTSTranslate(MainTranslate):
         self._dict["DIF AdisTS"] = _translate(
             "DIFAdisTS", "DIF AdisTS")
 
-        self._dict["kp"] = self._dict["unit_rk"]
+        self._dict["rk"] = self._dict["unit_rk"]
 
         self._sub_dict["table_headers"] = {
             "method": self._dict["method"],
@@ -42,8 +42,8 @@ class DIFAdisTSTranslate(MainTranslate):
         self._sub_dict["table_headers_spec"] = {
             "method": self._dict["method"],
             "reach": self._dict["reach"],
-            "start_kp": _translate("Unit", "Start_RK (m)"),
+            "start_rk": _translate("Unit", "Start_RK (m)"),
-            "end_kp": _translate("Unit", "End_RK (m)"),
+            "end_rk": _translate("Unit", "End_RK (m)"),
             "dif": _translate("Unit", "DIF"),
             "b": _translate("Unit", "Coeff b"),
             "c": _translate("Unit", "Coeff c"),

src/View/InitialConditionsAdisTS/Table.py

@@ -58,7 +58,7 @@ class ComboBoxDelegate(QItemDelegate):
         self.editor = QComboBox(parent)
 
         val = []
-        if self._mode == "kp":
+        if self._mode == "rk":
             reach_id = self._ic_spec_lst[index.row()].reach
 
             reach = next(filter(lambda edge: edge.id == reach_id, self._data.edges()))
@@ -66,7 +66,7 @@ class ComboBoxDelegate(QItemDelegate):
             if reach_id is not None:
                 val = list(
                     map(
-                        lambda kp: str(kp), reach.reach.get_kp()
+                        lambda rk: str(rk), reach.reach.get_rk()
                     )
                 )
         else:
@@ -137,13 +137,13 @@ class InitialConditionTableModel(PamhyrTableModel):
             if n is None:
                 return self._trad['not_associated']
             return next(filter(lambda edge: edge.id == n, self._river.edges())).name
-        elif self._headers[column] is "start_kp":
+        elif self._headers[column] is "start_rk":
-            n = self._lst[row].start_kp
+            n = self._lst[row].start_rk
             if n is None:
                 return self._trad['not_associated']
             return n
-        elif self._headers[column] is "end_kp":
+        elif self._headers[column] is "end_rk":
-            n = self._lst[row].end_kp
+            n = self._lst[row].end_rk
             if n is None:
                 return self._trad['not_associated']
             return n

src/View/InitialConditionsAdisTS/UndoCommand.py

@@ -88,10 +88,10 @@ class SetCommandSpec(QUndoCommand):
             self._old = self._data[self._row].name
         elif self._column == "reach":
             self._old = self._data[self._row].reach
-        elif self._column == "start_kp":
+        elif self._column == "start_rk":
-            self._old = self._data[self._row].start_kp
+            self._old = self._data[self._row].start_rk
-        elif self._column == "end_kp":
+        elif self._column == "end_rk":
-            self._old = self._data[self._row].end_kp
+            self._old = self._data[self._row].end_rk
         elif self._column == "concentration":
             self._old = self._data[self._row].concentration
         elif self._column == "eg":
@@ -116,10 +116,10 @@ class SetCommandSpec(QUndoCommand):
             self._data[self._row].name = self._old
         elif self._column == "reach":
             self._data[self._row].reach = self._old
-        elif self._column == "start_kp":
+        elif self._column == "start_rk":
-            self._data[self._row].start_kp = self._old
+            self._data[self._row].start_rk = self._old
-        elif self._column == "end_kp":
+        elif self._column == "end_rk":
-            self._data[self._row].end_kp = self._old
+            self._data[self._row].end_rk = self._old
         elif self._column == "concentration":
             self._data[self._row].concentration = self._old
         elif self._column == "eg":
@@ -136,10 +136,10 @@ class SetCommandSpec(QUndoCommand):
             self._data[self._row].name = self._new
         elif self._column == "reach":
             self._data[self._row].reach = self._new
-        elif self._column == "start_kp":
+        elif self._column == "start_rk":
-            self._data[self._row].start_kp = self._new
+            self._data[self._row].start_rk = self._new
-        elif self._column == "end_kp":
+        elif self._column == "end_rk":
-            self._data[self._row].end_kp = self._new
+            self._data[self._row].end_rk = self._new
         elif self._column == "concentration":
             self._data[self._row].concentration = self._new
         elif self._column == "eg":

src/View/InitialConditionsAdisTS/Window.py

@@ -140,22 +140,22 @@ class InitialConditionsAdisTSWindow(PamhyrWindow):
             parent=self,
             mode="reaches"
         )
-        self._delegate_kp = ComboBoxDelegate(
+        self._delegate_rk = ComboBoxDelegate(
             trad=self._trad,
             data=self._study.river,
             ic_spec_lst=self._data[0]._data,
             parent=self,
-            mode="kp"
+            mode="rk"
         )
 
         self._table_spec = InitialConditionTableModel(
             table_view=self.table_spec,
             table_headers=self._trad.get_dict("table_headers_spec"),
-            editable_headers=["name", "reach", "start_kp", "end_kp", "concentration", "eg", "em", "ed", "rate"],
+            editable_headers=["name", "reach", "start_rk", "end_rk", "concentration", "eg", "em", "ed", "rate"],
             delegates={
                 "reach": self._delegate_reach,
-                "start_kp": self._delegate_kp,
+                "start_rk": self._delegate_rk,
-                "end_kp": self._delegate_kp
+                "end_rk": self._delegate_rk
             },
             data=self._data[0],
             undo=self._undo_stack,
@@ -226,7 +226,7 @@ class InitialConditionsAdisTSWindow(PamhyrWindow):
                 lambda eic: list(
                     map(
                         lambda k: eic[1][k],
-                        ["kp", "discharge", "elevation"]
+                        ["rk", "discharge", "elevation"]
                     )
                 ),
                 filter(

src/View/InitialConditionsAdisTS/translate.py

@@ -30,7 +30,7 @@ class IcAdisTSTranslate(MainTranslate):
         self._dict["Initial condition AdisTS"] = _translate(
             "InitialConditionAdisTS", "Initial condition AdisTS")
 
-        self._dict["kp"] = self._dict["unit_rk"]
+        self._dict["rk"] = self._dict["unit_rk"]
 
         self._sub_dict["table_headers"] = {
             "name": self._dict["name"],
@@ -43,8 +43,8 @@ class IcAdisTSTranslate(MainTranslate):
         self._sub_dict["table_headers_spec"] = {
             "name": self._dict["name"],
             "reach": self._dict["reach"],
-            "start_kp": _translate("Unit", "Start_RK (m)"),
+            "start_rk": _translate("Unit", "Start_RK (m)"),
-            "end_kp": _translate("Unit", "End_RK (m)"),
+            "end_rk": _translate("Unit", "End_RK (m)"),
             "concentration": self._dict["unit_concentration"],
             "eg": _translate("Unit", "EG (m)"),
             "em": _translate("Unit", "EM (m)"),

src/View/LateralContributionsAdisTS/Table.py

@@ -67,7 +67,7 @@ class ComboBoxDelegate(QItemDelegate):
     def createEditor(self, parent, option, index):
         self.editor = QComboBox(parent)
 
-        if self._mode == "kp":
+        if self._mode == "rk":
             if self._data is None:
                 self.editor.addItems(
                     ["0"]
@@ -75,7 +75,7 @@ class ComboBoxDelegate(QItemDelegate):
             else:
                 self.editor.addItems(
                     list(
-                        map(str, self._data.reach.get_kp())
+                        map(str, self._data.reach.get_rk())
                     )
                 )
         else:
@@ -137,10 +137,10 @@ class TableModel(PamhyrTableModel):
             if n is None:
                 return self._trad['not_associated']
             return next(filter(lambda edge: edge.id == n, self._data.edges())).name
-        elif self._headers[column] == "begin_kp":
+        elif self._headers[column] == "begin_rk":
-            return str(self._lst[row].begin_kp)
+            return str(self._lst[row].begin_rk)
-        elif self._headers[column] == "end_kp":
+        elif self._headers[column] == "end_rk":
-            return str(self._lst[row].end_kp)
+            return str(self._lst[row].end_rk)
 
         return QVariant()
 
@@ -158,13 +158,13 @@ class TableModel(PamhyrTableModel):
                         self._lcs_list, self._lst, row, self._data.edge(value).id
                     )
                 )
-            elif self._headers[column] == "begin_kp":
+            elif self._headers[column] == "begin_rk":
                 self._undo.push(
                     SetBeginCommand(
                         self._lcs_list, self._lst, row, value
                     )
                 )
-            elif self._headers[column] == "end_kp":
+            elif self._headers[column] == "end_rk":
                 self._undo.push(
                     SetEndCommand(
                         self._lcs_list, self._lst, row, value

src/View/LateralContributionsAdisTS/UndoCommand.py

@@ -35,14 +35,14 @@ class SetBeginCommand(QUndoCommand):
         self._lcs = lcs
         self._lcs_lst = lcs_lst
         self._index = index
-        self._old = self._lcs_lst[self._index].begin_kp
+        self._old = self._lcs_lst[self._index].begin_rk
         self._new = float(new_value)
 
     def undo(self):
-        self._lcs_lst[self._index].begin_kp = float(self._old)
+        self._lcs_lst[self._index].begin_rk = float(self._old)
 
     def redo(self):
-        self._lcs_lst[self._index].begin_kp = float(self._new)
+        self._lcs_lst[self._index].begin_rk = float(self._new)
 
 
 class SetEndCommand(QUndoCommand):
@@ -52,14 +52,14 @@ class SetEndCommand(QUndoCommand):
         self._lcs = lcs
         self._lcs_lst = lcs_lst
         self._index = index
-        self._old = self._lcs_lst[self._index].end_kp
+        self._old = self._lcs_lst[self._index].end_rk
         self._new = float(new_value)
 
     def undo(self):
-        self._lcs_lst[self._index].end_kp = float(self._old)
+        self._lcs_lst[self._index].end_rk = float(self._old)
 
     def redo(self):
-        self._lcs_lst[self._index].end_kp = float(self._new)
+        self._lcs_lst[self._index].end_rk = float(self._new)
 
 
 class SetEdgeCommand(QUndoCommand):

src/View/LateralContributionsAdisTS/Window.py

@@ -80,15 +80,15 @@ class LateralContributionAdisTSWindow(PamhyrWindow):
     def setup_table(self):
         self._table = {}
 
-        self._delegate_kp = []
+        self._delegate_rk = []
 
-        delegate_kp = ComboBoxDelegate(
+        delegate_rk = ComboBoxDelegate(
             data=None,
-            mode="kp",
+            mode="rk",
             trad=self._trad,
             parent=self
         )
-        self._delegate_kp.append(delegate_kp)
+        self._delegate_rk.append(delegate_rk)
 
         self._delegate_edge = ComboBoxDelegate(
             data=self._study.river,
@@ -104,8 +104,8 @@ class LateralContributionAdisTSWindow(PamhyrWindow):
             editable_headers=self._trad.get_dict("table_headers"),
             delegates={
                 "edge": self._delegate_edge,
-                "begin_kp": delegate_kp,
+                "begin_rk": delegate_rk,
-                "end_kp": delegate_kp,
+                "end_rk": delegate_rk,
             },
             data=self._study.river,
             undo=self._undo_stack,
@@ -180,9 +180,9 @@ class LateralContributionAdisTSWindow(PamhyrWindow):
                 edge = next(filter(lambda e: e.id == edge_id, self._study.river.edges()))
                 data = edge.reach
                 lc = self._lcs.lst[rows[0]]
-                highlight = (lc.begin_kp, lc.end_kp)
+                highlight = (lc.begin_rk, lc.end_rk)
 
-                for delegate in self._delegate_kp:
+                for delegate in self._delegate_rk:
                     delegate.data = edge
 
         self.plot = PlotXY(

src/View/LateralContributionsAdisTS/translate.py

@@ -43,6 +43,6 @@ class LCTranslate(MainTranslate):
 
         self._sub_dict["table_headers"] = {
             "edge": self._dict["reach"],
-            "begin_kp": _translate("LateralContribution", "Begin kp (m)"),
+            "begin_rk": _translate("LateralContribution", "Begin rk (m)"),
-            "end_kp": _translate("LateralContribution", "End kp (m)")
+            "end_rk": _translate("LateralContribution", "End rk (m)")
         }

src/View/MainWindow.py

@@ -80,7 +80,7 @@ from View.Results.Window import ResultsWindow
 from View.Results.WindowAdisTS import ResultsWindowAdisTS
 from View.Results.ReadingResultsDialog import ReadingResultsDialog
 from View.Debug.Window import ReplWindow
-from View.OutputKpAdisTS.Window import OutputKpAdisTSWindow
+from View.OutputRKAdisTS.Window import OutputRKAdisTSWindow
 from View.Pollutants.Window import PollutantsWindow
 from View.D90AdisTS.Window import D90AdisTSWindow
 from View.DIFAdisTS.Window import DIFAdisTSWindow
@@ -127,7 +127,7 @@ define_model_action = [
     "action_menu_edit_hydraulic_structures", "action_menu_additional_file",
     "action_menu_results_last", "action_open_results_from_file",
     "action_menu_boundary_conditions_sediment",
-    "action_menu_rep_additional_lines", "action_menu_output_kp",
+    "action_menu_rep_additional_lines", "action_menu_output_rk",
     "action_menu_run_adists", "action_menu_pollutants",
     "action_menu_d90", "action_menu_dif",
 ]
@@ -243,7 +243,7 @@ class ApplicationWindow(QMainWindow, ListedSubWindow, WindowToolKit):
             "action_menu_d90": self.open_d90,
             "action_menu_pollutants": self.open_pollutants,
             "action_menu_run_adists":self.select_run_solver_adists,
-            "action_menu_output_kp": self.open_output_kp_adists,
+            "action_menu_output_rk": self.open_output_rk_adists,
             "action_menu_config": self.open_configure,
             "action_menu_new": self.open_new_study,
             "action_menu_edit": self.open_edit_study,
@@ -942,18 +942,18 @@ class ApplicationWindow(QMainWindow, ListedSubWindow, WindowToolKit):
         )
         Pollutants.show()
 
-    def open_output_kp_adists(self):
+    def open_output_rk_adists(self):
         if self.sub_window_exists(
-            OutputKpAdisTSWindow,
+            OutputRKAdisTSWindow,
             data=[self._study, None]
         ):
             return
 
-        Output_Kp_AdisTS = OutputKpAdisTSWindow(
+        Output_RK_AdisTS = OutputRKAdisTSWindow(
             study=self._study,
             parent=self
         )
-        Output_Kp_AdisTS.show()
+        Output_RK_AdisTS.show()
 
     def open_configure(self):
         """Open configure window

src/View/OutputRKAdisTS/Table.py

@@ -36,8 +36,8 @@ from PyQt5.QtWidgets import (
 
 from View.Tools.PamhyrTable import PamhyrTableModel
 
-from View.OutputKpAdisTS.UndoCommand import (
+from View.OutputRKAdisTS.UndoCommand import (
-    SetTitleCommand, SetReachCommand, SetKpCommand,
+    SetTitleCommand, SetReachCommand, SetRKCommand,
     SetEnabledCommand, AddCommand, DelCommand,
 )
 
@@ -60,8 +60,8 @@ class ComboBoxDelegate(QItemDelegate):
         self.editor = QComboBox(parent)
 
         val = []
-        if self._mode == "kp":
+        if self._mode == "rk":
-            reach_id = self._data.Output_kp_adists \
+            reach_id = self._data.Output_rk_adists \
                 .get(index.row()) \
                 .reach
 
@@ -70,7 +70,7 @@ class ComboBoxDelegate(QItemDelegate):
             if reach_id is not None:
                 val = list(
                     map(
-                        lambda kp: str(kp), reach.reach.get_kp()
+                        lambda rk: str(rk), reach.reach.get_rk()
                     )
                 )
         else:
@@ -112,7 +112,7 @@ class ComboBoxDelegate(QItemDelegate):
 
 class TableModel(PamhyrTableModel):
     def _setup_lst(self):
-        self._lst = self._data._Output_kp_adists
+        self._lst = self._data._Output_rk_adists
 
     def rowCount(self, parent):
         return len(self._lst)
@@ -131,8 +131,8 @@ class TableModel(PamhyrTableModel):
             if n is None:
                 return self._trad['not_associated']
             return next(filter(lambda edge: edge.id == n, self._data.edges())).name
-        elif self._headers[column] == "kp":
+        elif self._headers[column] == "rk":
-            n = self._lst.get(row).kp
+            n = self._lst.get(row).rk
             if n is None:
                 return self._trad['not_associated']
             return n
@@ -163,12 +163,12 @@ class TableModel(PamhyrTableModel):
                         self._lst, row, self._data.edge(value)
                     )
                 )
-            elif self._headers[column] == "kp":
+            elif self._headers[column] == "rk":
                 if value == na:
                     value = None
 
                 self._undo.push(
-                    SetKpCommand(
+                    SetRKCommand(
                         self._lst, row, value
                     )
                 )

src/View/OutputRKAdisTS/Translate.py

@@ -23,18 +23,18 @@ from View.Translate import MainTranslate
 _translate = QCoreApplication.translate
 
 
-class OutputKpAdisTSTranslate(MainTranslate):
+class OutputRKAdisTSTranslate(MainTranslate):
     def __init__(self):
-        super(OutputKpAdisTSTranslate, self).__init__()
+        super(OutputRKAdisTSTranslate, self).__init__()
 
-        self._dict["Output Kp"] = _translate(
+        self._dict["Output RK"] = _translate(
-            "OutputKpAdisTS", "Output Kp"
+            "OutputRKAdisTS", "Output RK"
         )
 
-        self._dict["x"] = _translate("OutputKpAdisTS", "X (m)")
+        self._dict["x"] = _translate("OutputRKAdisTS", "X (m)")
 
         self._sub_dict["table_headers"] = {
             "title": self._dict["title"],
             "reach": self._dict["reach"],
-            "kp": self._dict["unit_rk"],
+            "rk": self._dict["unit_rk"],
         }

src/View/OutputRKAdisTS/UndoCommand.py

@@ -29,127 +29,127 @@ logger = logging.getLogger()
 
 
 class SetTitleCommand(QUndoCommand):
-    def __init__(self, outputkp_lst, index, new_value):
+    def __init__(self, outputrk_lst, index, new_value):
         QUndoCommand.__init__(self)
 
-        self._outputkp_lst = outputkp_lst
+        self._outputrk_lst = outputrk_lst
         self._index = index
-        self._old = self._outputkp_lst.get(self._index).title
+        self._old = self._outputrk_lst.get(self._index).title
         self._new = str(new_value)
 
     def undo(self):
-        self._outputkp_lst.get(self._index).title = self._old
+        self._outputrk_lst.get(self._index).title = self._old
 
     def redo(self):
-        self._outputkp_lst.get(self._index).title = self._new
+        self._outputrk_lst.get(self._index).title = self._new
 
 
 class SetReachCommand(QUndoCommand):
-    def __init__(self, outputkp_lst, index, reach):
+    def __init__(self, outputrk_lst, index, reach):
         QUndoCommand.__init__(self)
 
-        self._outputkp_lst = outputkp_lst
+        self._outputrk_lst = outputrk_lst
         self._index = index
-        self._old = self._outputkp_lst.get(self._index).reach
+        self._old = self._outputrk_lst.get(self._index).reach
         self._new = reach.id
 
     def undo(self):
-        i = self._outputkp_lst.get(self._index)
+        i = self._outputrk_lst.get(self._index)
         i.reach = self._old
 
     def redo(self):
-        i = self._outputkp_lst.get(self._index)
+        i = self._outputrk_lst.get(self._index)
         i.reach = self._new
 
 
-class SetKpCommand(QUndoCommand):
+class SetRKCommand(QUndoCommand):
-    def __init__(self, outputkp_lst, index, kp):
+    def __init__(self, outputrk_lst, index, rk):
         QUndoCommand.__init__(self)
 
-        self._outputkp_lst = outputkp_lst
+        self._outputrk_lst = outputrk_lst
         self._index = index
-        self._old = self._outputkp_lst.get(self._index).kp
+        self._old = self._outputrk_lst.get(self._index).rk
-        self._new = kp
+        self._new = rk
 
     def undo(self):
-        self._outputkp_lst.get(self._index).kp = self._old
+        self._outputrk_lst.get(self._index).rk = self._old
 
     def redo(self):
-        self._outputkp_lst.get(self._index).kp = self._new
+        self._outputrk_lst.get(self._index).rk = self._new
 
 
 class SetEnabledCommand(QUndoCommand):
-    def __init__(self, outputkp_lst, index, enabled):
+    def __init__(self, outputrk_lst, index, enabled):
         QUndoCommand.__init__(self)
 
-        self._outputkp_lst = outputkp_lst
+        self._outputrk_lst = outputrk_lst
         self._index = index
         self._old = not enabled
         self._new = enabled
 
     def undo(self):
-        self._outputkp_lst.get(self._index).enabled = self._old
+        self._outputrk_lst.get(self._index).enabled = self._old
 
     def redo(self):
-        self._outputkp_lst.get(self._index).enabled = self._new
+        self._outputrk_lst.get(self._index).enabled = self._new
 
 
 class AddCommand(QUndoCommand):
-    def __init__(self, outputkp_lst, index):
+    def __init__(self, outputrk_lst, index):
         QUndoCommand.__init__(self)
 
-        self._outputkp_lst = outputkp_lst
+        self._outputrk_lst = outputrk_lst
 
         self._index = index
         self._new = None
 
     def undo(self):
-        self._outputkp_lst.delete_i([self._index])
+        self._outputrk_lst.delete_i([self._index])
 
     def redo(self):
         if self._new is None:
-            self._new = self._outputkp_lst.new(self._outputkp_lst, self._index)
+            self._new = self._outputrk_lst.new(self._outputrk_lst, self._index)
         else:
-            self._outputkp_lst.insert(self._index, self._new)
+            self._outputrk_lst.insert(self._index, self._new)
 
 
 class DelCommand(QUndoCommand):
-    def __init__(self, outputkp_lst, rows):
+    def __init__(self, outputrk_lst, rows):
         QUndoCommand.__init__(self)
 
-        self._outputkp_lst = outputkp_lst
+        self._outputrk_lst = outputrk_lst
 
         self._rows = rows
 
-        self._outputkp = []
+        self._outputrk = []
         for row in rows:
-            self._outputkp.append((row, self._outputkp_lst.get(row)))
+            self._outputrk.append((row, self._outputrk_lst.get(row)))
-        self._outputkp.sort()
+        self._outputrk.sort()
 
     def undo(self):
-        for row, el in self._outputkp:
+        for row, el in self._outputrk:
-            self._outputkp_lst.insert(row, el)
+            self._outputrk_lst.insert(row, el)
 
     def redo(self):
-        self._outputkp_lst.delete_i(self._rows)
+        self._outputrk_lst.delete_i(self._rows)
 
 
 class PasteCommand(QUndoCommand):
-    def __init__(self, outputkp_lst, row, outputkp):
+    def __init__(self, outputrk_lst, row, outputrk):
         QUndoCommand.__init__(self)
 
-        self._outputkp_lst = outputkp_lst
+        self._outputrk_lst = outputrk_lst
 
         self._row = row
-        self._outputkp = deepcopy(outputkp)
+        self._outputrk = deepcopy(outputrk)
-        self._outputkp.reverse()
+        self._outputrk.reverse()
 
     def undo(self):
-        self._outputkp_lst.delete_i(
+        self._outputrk_lst.delete_i(
             self._tab,
-            range(self._row, self._row + len(self._outputkp))
+            range(self._row, self._row + len(self._outputrk))
         )
 
     def redo(self):
-        for r in self._outputkp:
+        for r in self._outputrk:
-            self._outputkp_lst.insert(self._row, r)
+            self._outputrk_lst.insert(self._row, r)

src/View/OutputRKAdisTS/Window.py

@@ -38,25 +38,25 @@ from PyQt5.QtWidgets import (
 from View.Tools.Plot.PamhyrCanvas import MplCanvas
 from View.Tools.Plot.PamhyrToolbar import PamhyrPlotToolbar
 
-from View.OutputKpAdisTS.Table import (
+from View.OutputRKAdisTS.Table import (
     TableModel, ComboBoxDelegate,
 )
 
 from View.Network.GraphWidget import GraphWidget
-from View.OutputKpAdisTS.Translate import OutputKpAdisTSTranslate
+from View.OutputRKAdisTS.Translate import OutputRKAdisTSTranslate
 
 logger = logging.getLogger()
 
 
-class OutputKpAdisTSWindow(PamhyrWindow):
+class OutputRKAdisTSWindow(PamhyrWindow):
-    _pamhyr_ui = "OutputKpAdisTS"
+    _pamhyr_ui = "OutputRKAdisTS"
-    _pamhyr_name = "Output Kp"
+    _pamhyr_name = "Output RK"
 
     def __init__(self, study=None, config=None, parent=None):
-        trad = OutputKpAdisTSTranslate()
+        trad = OutputRKAdisTSTranslate()
         name = trad[self._pamhyr_name] + " - " + study.name
 
-        super(OutputKpAdisTSWindow, self).__init__(
+        super(OutputRKAdisTSWindow, self).__init__(
             title=name,
             study=study,
             config=config,
@@ -64,7 +64,7 @@ class OutputKpAdisTSWindow(PamhyrWindow):
             parent=parent
         )
 
-        self._outputkp_lst = self._study.river._Output_kp_adists
+        self._outputrk_lst = self._study.river._Output_rk_adists
 
         self.setup_table()
         self.setup_checkbox()
@@ -81,21 +81,21 @@ class OutputKpAdisTSWindow(PamhyrWindow):
             parent=self,
             mode="reaches"
         )
-        self._delegate_kp = ComboBoxDelegate(
+        self._delegate_rk = ComboBoxDelegate(
             trad=self._trad,
             data=self._study.river,
             parent=self,
-            mode="kp"
+            mode="rk"
         )
 
         table = self.find(QTableView, f"tableView")
         self._table = TableModel(
             table_view=table,
             table_headers=self._trad.get_dict("table_headers"),
-            editable_headers=["title", "reach", "kp"],
+            editable_headers=["title", "reach", "rk"],
             delegates={
                 "reach": self._delegate_reach,
-                "kp": self._delegate_kp,
+                "rk": self._delegate_rk,
             },
             trad=self._trad,
             data=self._study.river,
@@ -120,7 +120,7 @@ class OutputKpAdisTSWindow(PamhyrWindow):
     def setup_connections(self):
         self.find(QAction, "action_add").triggered.connect(self.add)
         self.find(QAction, "action_delete").triggered.connect(self.delete)
-        self._checkbox.clicked.connect(self._set_outputkp_state)
+        self._checkbox.clicked.connect(self._set_outputrk_state)
 
         table = self.find(QTableView, "tableView")
         table.selectionModel()\
@@ -162,7 +162,7 @@ class OutputKpAdisTSWindow(PamhyrWindow):
 
     def add(self):
         rows = self.index_selected_rows()
-        if len(self._outputkp_lst) == 0 or len(rows) == 0:
+        if len(self._outputrk_lst) == 0 or len(rows) == 0:
             self._table.add(0)
         else:
             self._table.add(rows[0])
@@ -193,9 +193,9 @@ class OutputKpAdisTSWindow(PamhyrWindow):
             self._checkbox.setChecked(True)
         else:
             self._checkbox.setEnabled(True)
-            self._checkbox.setChecked(self._outputkp_lst.get(row).enabled)
+            self._checkbox.setChecked(self._outputrk_lst.get(row).enabled)
 
-    def _set_outputkp_state(self):
+    def _set_outputrk_state(self):
         rows = self.index_selected_rows()
         if len(rows) != 0:
             for row in rows:

src/View/Results/TableAdisTS.py

@@ -87,14 +87,14 @@ class TableModel(PamhyrTableModel):
             if self._headers[column] == "name":
                 v = self._lst[row].name
                 return str(v)
-            elif self._headers[column] == "kp":
+            elif self._headers[column] == "rk":
-                v = self._lst[row].kp
+                v = self._lst[row].rk
                 return f"{v:.4f}"
         elif self._opt_data == "raw_data":
             p = self._lst[row]
             if self._headers[column] == "name":
                 if p.name == "":
-                    return f"{p.kp:.4f}"
+                    return f"{p.rk:.4f}"
                 return f"{p.name}"
             tmp_list = self._data.pollutants_list.copy()
             tmp_list.remove("total_sediment")

src/View/Results/WindowAdisTS.py

@@ -325,7 +325,7 @@ class ResultsWindowAdisTS(PamhyrWindow):
         else:
             profile = reach.reach.profile(indexes[0].row())
 
-        pname = profile.name if profile.name != "" else profile.kp
+        pname = profile.name if profile.name != "" else profile.rk
 
         # Pollutant
         table = self.find(QTableView, f"tableView_pollutants")
@@ -612,7 +612,7 @@ class ResultsWindowAdisTS(PamhyrWindow):
         with open(file_name, 'w', newline='') as csvfile:
             writer = csv.writer(csvfile, delimiter=',',
                                 quotechar='|', quoting=csv.QUOTE_MINIMAL)
-            writer.writerow(["name", "kp", "data-file"])
+            writer.writerow(["name", "rk", "data-file"])
             for profile in reach.profiles:
                 p_file_name = os.path.join(
                     directory,
@@ -621,7 +621,7 @@ class ResultsWindowAdisTS(PamhyrWindow):
 
                 writer.writerow([
                     profile.name,
-                    profile.kp,
+                    profile.rk,
                     p_file_name
                 ])
 

src/View/ui/MainWindow.ui

@@ -217,7 +217,7 @@
     <property name="title">
      <string>AdisTS</string>
     </property>
-    <addaction name="action_menu_output_kp"/>
+    <addaction name="action_menu_output_rk"/>
     <addaction name="action_menu_pollutants"/>
     <addaction name="action_menu_d90"/>
     <addaction name="action_menu_dif"/>
@@ -744,7 +744,7 @@
     <string>REP additional lines</string>
    </property>
   </action>
-  <action name="action_menu_output_kp">
+  <action name="action_menu_output_rk">
    <property name="text">
     <string>Output RK</string>
    </property>