floodmodeller-api 0.5.1__py3-none-any.whl → 0.5.2__py3-none-any.whl

floodmodeller_api/units/_helpers.py

@@ -0,0 +1,343 @@
+"""
+Flood Modeller Python API
+Copyright (C) 2025 Jacobs U.K. Limited
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program.  If not, see https://www.gnu.org/licenses/.
+
+If you have any query about this program or this License, please contact us at support@floodmodeller.com or write to the following
+address: Jacobs UK Limited, Flood Modeller, Cottons Centre, Cottons Lane, London, SE1 2QG, United Kingdom.
+"""
+
+from __future__ import annotations
+
+import copy
+from itertools import chain
+from typing import Any, Callable
+
+import pandas as pd
+
+NOTATION_THRESHOLD = 10
+
+
+def split_10_char(line: str) -> list[str]:
+    return split_n_char(line, 10)
+
+
+def split_12_char(line: str) -> list[str]:
+    return split_n_char(line, 12)
+
+
+def split_n_char(line: str, n: int) -> list[str]:
+    return [line[i : i + n].strip() for i in range(0, len(line), n)]
+
+
+def join_10_char(*itms, dp=3):
+    """Joins a set of values with a 10 character buffer and right-justified"""
+    string = ""
+    for itm in itms:
+        if itm is None:
+            itm = ""
+        if isinstance(itm, float):
+            # save to 3 dp
+            # Use scientific notation if number greater than NOTATION_THRESHOLD characters
+            itm = f"{itm:.{dp}e}" if len(f"{itm:.{dp}f}") > NOTATION_THRESHOLD else f"{itm:.{dp}f}"
+        itm = str(itm)
+        itm = itm[:10]
+        string += f"{itm:>10}"
+    return string
+
+
+def join_12_char_ljust(*itms, dp=3):
+    """Joins a set of values with a 12 character buffer and left-justified"""
+    return join_n_char_ljust(12, *itms, dp=dp)
+
+
+def join_n_char_ljust(n, *itms, dp=3):
+    """Joins a set of values with a n character buffer and left-justified"""
+    string = ""
+    for itm in itms:
+        if itm is None:
+            itm = ""
+        if isinstance(itm, float):
+            # save to 3 dp
+            # Use scientific notation if number greater than 10 characters
+            itm = f"{itm:.{dp}e}" if len(f"{itm:.{dp}f}") > NOTATION_THRESHOLD else f"{itm:.{dp}f}"
+        itm = str(itm)
+        itm = itm[:n]
+        string += f"{itm:<{n}}"
+    return string
+
+
+def to_float(itm, default=0.0):
+    try:
+        return float(itm)
+    except ValueError:
+        return default
+
+
+def to_int(itm, default=0):
+    try:
+        return int(itm)
+    except ValueError:
+        return default
+
+
+def to_str(itm, default, check_float=False):
+    if check_float:
+        try:
+            return float(itm)
+        except ValueError:
+            pass
+    if itm == "":
+        return default
+    return itm
+
+
+def to_data_list(block: list[str], num_cols: int | None = None, date_col: int | None = None):
+    if num_cols is not None:
+        num_cols += 1 if date_col is not None else 0
+    data_list = []
+    for row in block:
+        row_split = split_10_char(row) if num_cols is None else split_10_char(row)[:num_cols]
+        if date_col is not None:
+            date_time = " ".join(row_split[date_col : date_col + 2])
+            row_split = [
+                to_float(itm)
+                for idx, itm in enumerate(row_split)
+                if idx not in (date_col, date_col + 1)
+            ]
+            row_split.insert(date_col, date_time)
+        else:
+            row_split = [to_float(itm) for itm in row_split]
+
+        row_list = list(row_split)
+        data_list.append(row_list)
+    return data_list
+
+
+def set_bridge_params(obj: Any, line: str, *, include_pier: bool = True) -> None:
+    params = split_10_char(f"{line:<90}")
+    obj.calibration_coefficient = to_float(params[0], 1.0)
+    obj.skew = to_float(params[1])
+    obj.bridge_width_dual = to_float(params[2])
+    obj.bridge_dist_dual = to_float(params[3])
+    if include_pier:
+        obj.total_pier_width = to_float(params[4])
+    obj.orifice_flow = params[5] == "ORIFICE"
+    obj.orifice_lower_transition_dist = to_float(params[6])
+    obj.orifice_upper_transition_dist = to_float(params[7])
+    obj.orifice_discharge_coefficient = to_float(params[8], 1.0)
+
+
+def set_pier_params(obj: Any, line: str) -> None:
+    pier_info = split_10_char(line)
+    if int(pier_info[0]) > 0:
+        obj.specify_piers = True
+        obj.npiers = int(pier_info[0])
+        if pier_info[1] == "COEFF":
+            obj.pier_use_calibration_coeff = True
+            obj.pier_calibration_coeff = to_float(pier_info[3])
+        else:
+            obj.pier_use_calibration_coeff = False
+            obj.pier_shape = pier_info[1]
+            obj.pier_faces = pier_info[2]
+    else:
+        obj.specify_piers = False
+        obj.soffit_shape = pier_info[1]
+
+
+def read_dataframe_from_lines(
+    all_lines: list[str],
+    end_idx: int,
+    read_lines: Callable[[list[str]], pd.DataFrame],
+    *args,
+    **kwargs,
+) -> tuple[int, int, pd.DataFrame]:
+    nrows = get_int(all_lines[end_idx])
+    start_idx = end_idx + 1
+    end_idx = start_idx + nrows
+    data = read_lines(all_lines[start_idx:end_idx], *args, **kwargs)
+    return nrows, end_idx, data
+
+
+def read_bridge_cross_sections(
+    lines: list[str],
+    *,
+    include_panel_marker: bool = False,
+    include_top_level: bool = False,
+) -> pd.DataFrame:
+    data_list = []
+    for line in lines:
+        line_split = split_10_char(f"{line:<50}")
+        df_row = [
+            to_float(line_split[0]),
+            to_float(line_split[1]),
+            to_float(line_split[2]),
+        ]
+
+        if include_panel_marker:
+            df_row.append(line_split[3])
+
+        df_row.append(line_split[4])
+
+        if include_top_level:
+            df_row.append(line_split[5])
+
+        data_list.append(df_row)
+
+    columns = ["X", "Y", "Mannings n"]
+
+    if include_panel_marker:
+        columns.append("Panel")
+
+    columns.append("Embankments")
+
+    if include_top_level:
+        columns.append("Top Level")
+    return pd.DataFrame(data_list, columns=columns)
+
+
+def read_bridge_opening_data(lines: list[str]) -> pd.DataFrame:
+    data_list = []
+    for line in lines:
+        line_split = split_10_char(f"{line:<40}")
+        start = to_float(line_split[0])
+        finish = to_float(line_split[1])
+        spring = to_float(line_split[2])
+        soffit = to_float(line_split[3])
+        data_list.append([start, finish, spring, soffit])
+    return pd.DataFrame(data_list, columns=["Start", "Finish", "Springing Level", "Soffit Level"])
+
+
+def read_bridge_culvert_data(lines: list[str]) -> pd.DataFrame:
+    data_list = []
+    for line in lines:
+        line_split = split_10_char(f"{line:<70}")
+        invert = to_float(line_split[0])
+        soffit = to_float(line_split[1])
+        area = to_float(line_split[2])
+        cd_part = to_float(line_split[3])
+        cd_full = to_float(line_split[4])
+        dlinen = to_float(line_split[5])
+        x = to_float(line_split[6])
+        data_list.append([invert, soffit, area, cd_part, cd_full, dlinen, x])
+    return pd.DataFrame(
+        data_list,
+        columns=[
+            "Invert",
+            "Soffit",
+            "Section Area",
+            "Cd Part Full",
+            "Cd Full",
+            "Drowning Coefficient",
+            "X",
+        ],
+    )
+
+
+def read_bridge_pier_locations(lines: list[str]) -> pd.DataFrame:
+    data_list = []
+    for line in lines:
+        line_split = split_10_char(f"{line:<40}")
+        l_x = to_float(line_split[0])
+        l_top_level = to_float(line_split[1])
+        r_x = to_float(line_split[2])
+        r_top_level = to_float(line_split[3])
+        data_list.append([l_x, l_top_level, r_x, r_top_level])
+    return pd.DataFrame(
+        data_list,
+        columns=["Left X", "Left Top Level", "Right X", "Right Top Level"],
+    )
+
+
+def read_spill_section_data(lines: list[str]) -> pd.DataFrame:
+    data_list = []
+    for line in lines:
+        line_split = split_10_char(f"{line:<40}")
+        chainage = to_float(line_split[0])
+        elevation = to_float(line_split[1])
+        easting = to_float(line_split[2])
+        northing = to_float(line_split[3])
+        data_list.append([chainage, elevation, easting, northing])
+    return pd.DataFrame(data_list, columns=["X", "Y", "Easting", "Northing"])
+
+
+def read_superbridge_opening_data(lines: list[str]) -> pd.DataFrame:
+    data_list = []
+    for line in lines:
+        line_split = split_10_char(f"{line:<20}")
+        x = to_float(line_split[0])
+        z = to_float(line_split[1])
+        data_list.append([x, z])
+    return pd.DataFrame(data_list, columns=["X", "Z"])
+
+
+def read_superbridge_block_data(lines: list[str]) -> pd.DataFrame:
+    data_list = []
+    for line in lines:
+        line_split = split_10_char(f"{line:<30}")
+        percentage = to_int(line_split[0])
+        time = to_float(line_split[1])
+        datetime = to_float(line_split[2])
+        data_list.append([percentage, time, datetime])
+    return pd.DataFrame(data_list, columns=["percentage", "time", "datetime"])
+
+
+def read_lateral_data(lines: list[str]) -> pd.DataFrame:
+    data_list = []
+    for line in lines:
+        line_split = split_12_char(f"{line:<36}")
+        label = line_split[0]
+        factor = to_float(line_split[1])
+        flag = line_split[2]
+        data_list.append([label, factor, flag])
+    columns = ["Node Label", "Custom Weight Factor", "Use Weight Factor"]
+    return pd.DataFrame(data_list, columns=columns)
+
+
+def read_reservoir_data(lines: list[str]) -> pd.DataFrame:
+    data_list = []
+    for line in lines:
+        line_split = split_10_char(f"{line:<20}")
+        elevation = to_float(line_split[0])
+        area = to_float(line_split[1])
+        data_list.append([elevation, area])
+    columns = ["Elevation", "Plan Area"]
+    return pd.DataFrame(data_list, columns=columns)
+
+
+def get_int(line: str) -> int:
+    return int(float(split_10_char(line)[0]))
+
+
+def write_dataframe(
+    header: int | str | None,
+    df: pd.DataFrame,
+    empty: int | None = None,
+    n: int = 10,
+) -> list[str]:
+    df_to_use = copy.deepcopy(df)
+    if empty is not None:
+        df_to_use.insert(empty, "_", [None] * len(df_to_use))
+    lines = [join_n_char_ljust(n, *x) for x in df_to_use.itertuples(index=False)]
+    if header is not None:
+        lines = [str(header), *lines]
+    return lines
+
+
+def write_dataframes(
+    header: int | str | None,
+    subheaders: list[int],
+    df_list: list[pd.DataFrame],
+) -> list[str]:
+    list_of_lists = [write_dataframe(x, y) for x, y in zip(subheaders, df_list)]
+    lines = list(chain.from_iterable(list_of_lists))
+    if header is not None:
+        lines = [str(header), *lines]
+    return lines

floodmodeller_api/units/boundaries.py

@@ -1,6 +1,6 @@
 """
 Flood Modeller Python API
-Copyright (C) 2024 Jacobs U.K. Limited
+Copyright (C) 2025 Jacobs U.K. Limited
 
 This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
@@ -20,14 +20,13 @@ from floodmodeller_api.validation import _validate_unit
 from floodmodeller_api.validation.parameters import parameter_options
 
 from ._base import Unit
-from .helpers import (
-    _to_data_list,
-    _to_float,
-    _to_int,
-    _to_str,
+from ._helpers import (
     join_10_char,
     join_n_char_ljust,
     split_10_char,
+    to_data_list,
+    to_float,
+    to_str,
 )
 
 
@@ -82,13 +81,6 @@ class QTBDY(Unit):
         }.items():
             setattr(self, param, val)
 
-        # AL Since this is most likely used when building a model,
-        # AL it would be nice to have a "name generator" to create
-        # AL a unique name with each call (ie new_qtbdy_12345 then new_qtbdy_02508)
-        # JP Yes this is a good idea, although I'm not sure how it would be best implemented
-        #   since any two instances of the class being initialised would be unaware of each other?
-        #   There is always the option to pass a name when constrcuting the class which may be better
-
         self.data = (
             data
             if isinstance(data, pd.Series)
@@ -98,21 +90,21 @@ class QTBDY(Unit):
     def _read(self, qtbdy_block):
         """Function to read a given QTBDY block and store data as class attributes"""
         self.name = qtbdy_block[1][: self._label_len].strip()
-        self.comment = qtbdy_block[0].replace("QTBDY", "").strip()
+        self.comment = self._remove_unit_name(qtbdy_block[0])
         qtbdy_params = split_10_char(f"{qtbdy_block[2]:<90}")
         self.nrows = int(qtbdy_params[0])
-        self.timeoffset = _to_float(qtbdy_params[1])
-        self._something = _to_float(qtbdy_params[2])
-        self.timeunit = _to_str(qtbdy_params[3], "HOURS", check_float=True)
-        self.extendmethod = _to_str(qtbdy_params[4], "EXTEND")
-        self.interpmethod = _to_str(qtbdy_params[5], "LINEAR")
-        self.flowmultiplier = _to_float(qtbdy_params[6])
-        self.minflow = _to_float(qtbdy_params[7])
-        self.allow_override = _to_str(qtbdy_params[8], "OVERRIDE")  # ''/OVERRIDE or NOOVERRIDE
+        self.timeoffset = to_float(qtbdy_params[1])
+        self._something = to_float(qtbdy_params[2])
+        self.timeunit = to_str(qtbdy_params[3], "HOURS", check_float=True)
+        self.extendmethod = to_str(qtbdy_params[4], "EXTEND")
+        self.interpmethod = to_str(qtbdy_params[5], "LINEAR")
+        self.flowmultiplier = to_float(qtbdy_params[6])
+        self.minflow = to_float(qtbdy_params[7])
+        self.allow_override = to_str(qtbdy_params[8], "OVERRIDE")  # ''/OVERRIDE or NOOVERRIDE
         data_list = (
-            _to_data_list(qtbdy_block[3:], date_col=1)
+            to_data_list(qtbdy_block[3:], date_col=1)
             if self.timeunit == "DATES"
-            else _to_data_list(qtbdy_block[3:])
+            else to_data_list(qtbdy_block[3:])
         )
 
         self.data = pd.DataFrame(data_list, columns=["Flow", "Time"])
@@ -122,7 +114,7 @@ class QTBDY(Unit):
     def _write(self):
         """Function to write a valid QTBDY block"""
         _validate_unit(self)  # Function to check the params are valid for QTBDY
-        header = "QTBDY " + self.comment
+        header = self._create_header()
         name = self.name[: self._label_len]
         self.nrows = len(self.data)
 
@@ -195,18 +187,18 @@ class HTBDY(Unit):
     def _read(self, htbdy_block):
         """Function to read a given HTBDY block and store data as class attributes"""
         self.name = htbdy_block[1][: self._label_len].strip()
-        self.comment = htbdy_block[0].replace("HTBDY", "").strip()
+        self.comment = self._remove_unit_name(htbdy_block[0])
         htbdy_params = split_10_char(f"{htbdy_block[2]:<50}")
         self.nrows = int(htbdy_params[0])
-        self._something = _to_str(htbdy_params[1], "")
-        self.timeunit = _to_str(htbdy_params[2], "HOURS", check_float=True)
-        self.extendmethod = _to_str(htbdy_params[3], "EXTEND")
-        self.interpmethod = _to_str(htbdy_params[4], "LINEAR")
+        self._something = to_str(htbdy_params[1], "")
+        self.timeunit = to_str(htbdy_params[2], "HOURS", check_float=True)
+        self.extendmethod = to_str(htbdy_params[3], "EXTEND")
+        self.interpmethod = to_str(htbdy_params[4], "LINEAR")
 
         data_list = (
-            _to_data_list(htbdy_block[3:], date_col=1)
+            to_data_list(htbdy_block[3:], date_col=1)
             if self.timeunit == "DATES"
-            else _to_data_list(htbdy_block[3:])
+            else to_data_list(htbdy_block[3:])
         )
 
         self.data = pd.DataFrame(data_list, columns=["Stage", "Time"])
@@ -221,7 +213,7 @@ class HTBDY(Unit):
     def _write(self):
         """Function to write a valid HTBDY block"""
         _validate_unit(self)  # Function to check the params are valid for HTBDY
-        header = "HTBDY " + self.comment
+        header = self._create_header()
         name = self.name
         self.nrows = len(self.data)
 
@@ -273,12 +265,12 @@ class QHBDY(Unit):
     def _read(self, qhbdy_block):
         """Function to read a given QHBDY block and store data as class attributes"""
         self.name = qhbdy_block[1][: self._label_len].strip()
-        self.comment = qhbdy_block[0].replace("QHBDY", "").strip()
+        self.comment = self._remove_unit_name(qhbdy_block[0])
         qhbdy_params = split_10_char(f"{qhbdy_block[2]:<30}")
         self.nrows = int(qhbdy_params[0])
-        self.interpmethod = _to_str(qhbdy_params[2], "LINEAR")
+        self.interpmethod = to_str(qhbdy_params[2], "LINEAR")
 
-        data_list = _to_data_list(qhbdy_block[3:])
+        data_list = to_data_list(qhbdy_block[3:])
 
         self.data = pd.DataFrame(data_list, columns=["Flow", "Stage"])
         self.data = self.data.set_index("Stage")
@@ -287,7 +279,7 @@ class QHBDY(Unit):
     def _write(self):
         """Function to write a valid QHBDY block"""
         _validate_unit(self)  # Function to check the params are valid for QHBDY
-        header = "QHBDY " + self.comment
+        header = self._create_header()
         name = self.name
         self.nrows = len(self.data)
 
@@ -348,43 +340,40 @@ class REFHBDY(Unit):
         """Function to read a given REFHBDY block and store data as class attributes"""
         # line 1 & 2
         # Extract comment and revision number
-        b = refhbdy_block[0].replace("REFHBDY #revision#", "").strip()
-        self._revision = _to_int(b[0], 1)
-        self.comment = b[1:].strip()
+        self._revision, self.comment = self._get_revision_and_comment(refhbdy_block[0])
         self.name = refhbdy_block[1][: self._label_len].strip()
 
         # line 3
         refhbdy_params1 = split_10_char(refhbdy_block[2])
-        # TODO: work out what this is
-        self._something = _to_float(refhbdy_params1[0])
+        self._unknown_param_1 = to_float(refhbdy_params1[0])
         self.easting = int(float(refhbdy_params1[1]))
         self.northing = int(float(refhbdy_params1[2]))
 
         # line 4
         refhbdy_opts = split_10_char(f"{refhbdy_block[3]:<90}")
-        self.time_delay = _to_float(refhbdy_opts[0])
+        self.time_delay = to_float(refhbdy_opts[0])
         # SD / timestep must be odd interval
-        self.timestep = _to_float(refhbdy_opts[1])
+        self.timestep = to_float(refhbdy_opts[1])
         # '' : Full hydrograph, 'pfonly' : peak flow, 'bfonly' : baseflow only
         self.sim_type = refhbdy_opts[2]
-        self.scale_method = _to_str(refhbdy_opts[3], "SCALEFACT")  # PEAKVALUE or SCALEFACT
-        self.scale_value = _to_float(refhbdy_opts[4], 1.0)
-        self.boundary_type = _to_str(refhbdy_opts[5], "HYDROGRAPH")  # HYDROGRAPH or HYETOGRAPH
-        self.scale_type = _to_str(refhbdy_opts[6], "FULL")  # FULL or RUNOFF
-        self.minflow = _to_float(refhbdy_opts[7])
+        self.scale_method = to_str(refhbdy_opts[3], "SCALEFACT")  # PEAKVALUE or SCALEFACT
+        self.scale_value = to_float(refhbdy_opts[4], 1.0)
+        self.boundary_type = to_str(refhbdy_opts[5], "HYDROGRAPH")  # HYDROGRAPH or HYETOGRAPH
+        self.scale_type = to_str(refhbdy_opts[6], "FULL")  # FULL or RUNOFF
+        self.minflow = to_float(refhbdy_opts[7])
         self.allow_override = refhbdy_opts[8]  # ''/OVERRIDE or NOOVERRIDE
 
         # line 5
         refhbdy_params2 = split_10_char(f"{refhbdy_block[4]:<60}")
-        self.area = _to_float(refhbdy_params2[0])
+        self.area = to_float(refhbdy_params2[0])
         try:
             # Maintain SAAR as integer if already is, else use float
             self.saar = int(refhbdy_params2[1])
         except ValueError:
             self.saar = float(refhbdy_params2[1])
-        self.urbext = _to_float(refhbdy_params2[2])
-        self.season = _to_str(refhbdy_params2[3], "DEFAULT")  # DEFAULT, SUMMER or WINTER
-        self.calc_source = _to_str(refhbdy_params2[4], "DLL")  # DLL or REPORT
+        self.urbext = to_float(refhbdy_params2[2])
+        self.season = to_str(refhbdy_params2[3], "DEFAULT")  # DEFAULT, SUMMER or WINTER
+        self.calc_source = to_str(refhbdy_params2[4], "DLL")  # DLL or REPORT
         self.use_urban_subdivisions = refhbdy_params2[5] != ""
         if self.use_urban_subdivisions:
             # Just keeping this raw for now as unlikely to be used.
@@ -399,37 +388,36 @@ class REFHBDY(Unit):
 
         # line 6
         rainfall_params1 = split_10_char(rainfall_params1)
-        self.storm_area = _to_float(rainfall_params1[0])
-        self.storm_duration = _to_float(rainfall_params1[1])
-        # TODO: work out what this is
-        self._something2 = _to_float(rainfall_params1[2])
+        self.storm_area = to_float(rainfall_params1[0])
+        self.storm_duration = to_float(rainfall_params1[1])
+        self._unknown_param_2 = to_float(rainfall_params1[2])
 
         # line 7
         self.rainfall_comment = rainfall_params2[20:]
         rainfall_params2 = split_10_char(rainfall_params2[:20])
         self.arf_method = rainfall_params2[1]
-        self._something3 = rainfall_params2[0]  # TODO: work out what this is
+        self._unknown_param_3 = rainfall_params2[0]
 
         # line 8
         rainfall_params3 = split_10_char(rainfall_params3)
-        self.observed_rainfall_depth = _to_float(rainfall_params3[0])
-        self.return_period = _to_float(rainfall_params3[1])
-        self.arf = _to_float(rainfall_params3[2])
-        self.ddf_c = _to_float(rainfall_params3[3])
-        self.ddf_d1 = _to_float(rainfall_params3[4])
-        self.ddf_d2 = _to_float(rainfall_params3[5])
-        self.ddf_d3 = _to_float(rainfall_params3[6])
-        self.ddf_e = _to_float(rainfall_params3[7])
-        self.ddf_f = _to_float(rainfall_params3[8])
+        self.observed_rainfall_depth = to_float(rainfall_params3[0])
+        self.return_period = to_float(rainfall_params3[1])
+        self.arf = to_float(rainfall_params3[2])
+        self.ddf_c = to_float(rainfall_params3[3])
+        self.ddf_d1 = to_float(rainfall_params3[4])
+        self.ddf_d2 = to_float(rainfall_params3[5])
+        self.ddf_d3 = to_float(rainfall_params3[6])
+        self.ddf_e = to_float(rainfall_params3[7])
+        self.ddf_f = to_float(rainfall_params3[8])
 
     def _write(self):
         """Function to write a valid REFHBDY block"""
         _validate_unit(self)  # Function to check the params are valid for QTBDY
-        header = f"REFHBDY #revision#{self._revision} {self.comment}"
+        header = self._create_header(include_revision=True)
         name = self.name[: self._label_len]
 
         refhbdy_block = [header, name]
-        line3 = join_10_char(self._something, self.easting, self.northing)
+        line3 = join_10_char(self._unknown_param_1, self.easting, self.northing)
         self.sim_type = (
             "" if self.sim_type.upper() == "FULL" else self.sim_type
         )  # Allow 'full' as an option
@@ -454,8 +442,8 @@ class REFHBDY(Unit):
         if self.use_urban_subdivisions:
             refhbdy_block.extend(self._urban_refh_data)
 
-        line6 = join_10_char(self.storm_area, self.storm_duration, self._something2)
-        line7 = join_10_char(self._something3, self.arf_method) + self.rainfall_comment
+        line6 = join_10_char(self.storm_area, self.storm_duration, self._unknown_param_2)
+        line7 = join_10_char(self._unknown_param_3, self.arf_method) + self.rainfall_comment
         line8 = join_10_char(
             self.observed_rainfall_depth,
             self.return_period,

floodmodeller_api/units/comment.py

@@ -1,6 +1,6 @@
 """
 Flood Modeller Python API
-Copyright (C) 2024 Jacobs U.K. Limited
+Copyright (C) 2025 Jacobs U.K. Limited
 
 This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.