floodmodeller-api 0.5.0.post1__py3-none-any.whl → 0.5.2__py3-none-any.whl

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.

floodmodeller_api/units/conduits.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.
@@ -14,19 +14,21 @@ If you have any query about this program or this License, please contact us at s
 address: Jacobs UK Limited, Flood Modeller, Cottons Centre, Cottons Lane, London, SE1 2QG, United Kingdom.
 """
 
+import logging
+
 import pandas as pd
 
 from floodmodeller_api.validation import _validate_unit
 
 from ._base import Unit
-from .helpers import (
-    _to_float,
-    _to_int,
-    _to_str,
+from ._helpers import (
     join_10_char,
     join_n_char_ljust,
     split_10_char,
     split_n_char,
+    to_float,
+    to_int,
+    to_str,
 )
 
 
@@ -179,93 +181,94 @@ class CONDUIT(Unit):
 
     def _read(self, c_block):  # noqa: PLR0915
         """Function to read a given CONDUIT block and store data as class attributes"""
-        self._subtype = c_block[1].split(" ")[0].strip()
+        self._subtype = self._get_first_word(c_block[1])
         # Extends label line to be correct length before splitting to pick up blank labels
         labels = split_n_char(f"{c_block[2]:<{2*self._label_len}}", self._label_len)
         self.name = labels[0]
         self.spill = labels[1]
-        self.comment = c_block[0].replace("CONDUIT", "").strip()
+        self.comment = self._remove_unit_name(c_block[0])
 
         # Read CIRCULAR type unit
         if self._subtype == "CIRCULAR":
             # Read Params
-            self.dist_to_next = _to_float(split_10_char(c_block[3])[0])
+            self.dist_to_next = to_float(split_10_char(c_block[3])[0])
             self.friction_eq = c_block[4].strip()
             params = split_10_char(f"{c_block[5]:<80}")
-            self.invert = _to_float(params[0])
-            self.diameter = _to_float(params[1])
-            self.use_bottom_slot = _to_str(params[2], "GLOBAL")
-            self.bottom_slot_dist = _to_float(params[3])
-            self.bottom_slot_depth = _to_float(params[4])
-            self.use_top_slot = _to_str(params[5], "GLOBAL")
-            self.top_slot_dist = _to_float(params[6])
-            self.top_slot_depth = _to_float(params[7])
+            self.invert = to_float(params[0])
+            self.diameter = to_float(params[1])
+            self.use_bottom_slot = to_str(params[2], "GLOBAL")
+            self.bottom_slot_dist = to_float(params[3])
+            self.bottom_slot_depth = to_float(params[4])
+            self.use_top_slot = to_str(params[5], "GLOBAL")
+            self.top_slot_dist = to_float(params[6])
+            self.top_slot_depth = to_float(params[7])
             friction_params = split_10_char(f"{c_block[6]:<20}")
-            self.friction_below_axis = _to_float(friction_params[0])
-            self.friction_above_axis = _to_float(friction_params[1])
+            self.friction_below_axis = to_float(friction_params[0])
+            self.friction_above_axis = to_float(friction_params[1])
 
         elif self._subtype == "RECTANGULAR":
             # Read Params
-            self.dist_to_next = _to_float(split_10_char(c_block[3])[0])
+            self.dist_to_next = to_float(split_10_char(c_block[3])[0])
             self.friction_eq = c_block[4].strip()
             params = split_10_char(f"{c_block[5]:<90}")
-            self.invert = _to_float(params[0])
-            self.width = _to_float(params[1])
-            self.height = _to_float(params[2])
-            self.use_bottom_slot = _to_str(params[3], "GLOBAL")
-            self.bottom_slot_dist = _to_float(params[4])
-            self.bottom_slot_depth = _to_float(params[5])
-            self.use_top_slot = _to_str(params[6], "GLOBAL")
-            self.top_slot_dist = _to_float(params[7])
-            self.top_slot_depth = _to_float(params[8])
+            self.invert = to_float(params[0])
+            self.width = to_float(params[1])
+            self.height = to_float(params[2])
+            self.use_bottom_slot = to_str(params[3], "GLOBAL")
+            self.bottom_slot_dist = to_float(params[4])
+            self.bottom_slot_depth = to_float(params[5])
+            self.use_top_slot = to_str(params[6], "GLOBAL")
+            self.top_slot_dist = to_float(params[7])
+            self.top_slot_depth = to_float(params[8])
             friction_params = split_10_char(f"{c_block[6]:<30}")
-            self.friction_on_invert = _to_float(friction_params[0])
-            self.friction_on_walls = _to_float(friction_params[1])
-            self.friction_on_soffit = _to_float(friction_params[2])
+            self.friction_on_invert = to_float(friction_params[0])
+            self.friction_on_walls = to_float(friction_params[1])
+            self.friction_on_soffit = to_float(friction_params[2])
 
         elif self._subtype in ("SPRUNG", "SPRUNGARCH"):
-            self.dist_to_next = _to_float(split_10_char(c_block[3])[0])
-            self.equation = _to_str(c_block[4], "MANNING")
+            self.dist_to_next = to_float(split_10_char(c_block[3])[0])
+            self.equation = to_str(c_block[4], "MANNING")
             params = split_10_char(f"{c_block[5]:<100}")
-            self.elevation_invert = _to_float(params[0])
-            self.width = _to_float(params[1])
-            self.height_springing = _to_float(params[2])
-            self.height_crown = _to_float(params[3])
-            self.use_bottom_slot = _to_str(params[4], "GLOBAL")
-            self.bottom_slot_dist = _to_float(params[5])
-            self.bottom_slot_depth = _to_float(params[6])
-            self.use_top_slot = _to_str(params[7], "GLOBAL")
-            self.top_slot_dist = _to_float(params[8])
-            self.top_slot_depth = _to_float(params[9])
+            self.elevation_invert = to_float(params[0])
+            self.width = to_float(params[1])
+            self.height_springing = to_float(params[2])
+            self.height_crown = to_float(params[3])
+            self.use_bottom_slot = to_str(params[4], "GLOBAL")
+            self.bottom_slot_dist = to_float(params[5])
+            self.bottom_slot_depth = to_float(params[6])
+            self.use_top_slot = to_str(params[7], "GLOBAL")
+            self.top_slot_dist = to_float(params[8])
+            self.top_slot_depth = to_float(params[9])
             friction_params = split_10_char(f"{c_block[6]:<30}")
-            self.friction_on_invert = _to_float(friction_params[0])
-            self.friction_on_walls = _to_float(friction_params[1])
-            self.friction_on_soffit = _to_float(friction_params[2])
+            self.friction_on_invert = to_float(friction_params[0])
+            self.friction_on_walls = to_float(friction_params[1])
+            self.friction_on_soffit = to_float(friction_params[2])
 
         elif self._subtype == "SECTION":
-            self.dist_to_next = _to_float(split_10_char(c_block[3])[0])
-            end_index = 5 + _to_int(c_block[4])
+            self.dist_to_next = to_float(split_10_char(c_block[3])[0])
+            end_index = 5 + to_int(c_block[4])
             x = []
             y = []
             friction = []
             for i in range(5, end_index):
                 row_data = split_10_char(f"{c_block[i]:<30}")
-                x.append(_to_float(row_data[0]))
-                y.append(_to_float(row_data[1]))
-                friction.append(_to_float(row_data[2]))
+                x.append(to_float(row_data[0]))
+                y.append(to_float(row_data[1]))
+                friction.append(to_float(row_data[2]))
             self.coords = pd.DataFrame({"x": x, "y": y, "cw_friction": friction})
 
         else:
             # This else block is triggered for conduit subtypes which aren't yet supported, and just keeps the '_block' in it's raw state to write back.
-            print(
-                f'This Conduit sub-type: "{self._subtype}" is currently unsupported for reading/editing',
+            logging.warning(
+                "This Conduit sub-type: '%s' is currently unsupported for reading/editing",
+                self._subtype,
             )
             self._raw_block = c_block
 
     def _write(self):
         """Function to write a valid CONDUIT block"""
         _validate_unit(self)  # Function to check the params are valid for CONDUIT unit
-        header = "CONDUIT " + self.comment
+        header = self._create_header()
         labels = join_n_char_ljust(self._label_len, self.name, self.spill)
         c_block = [header, self._subtype, labels]
 

floodmodeller_api/units/connectors.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from floodmodeller_api.validation import _validate_unit
+
+from ._base import Unit
+from ._helpers import (
+    join_12_char_ljust,
+    read_lateral_data,
+    split_12_char,
+    to_int,
+    write_dataframe,
+)
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+
+class JUNCTION(Unit):
+    """Class to hold and process JUNCTION unit type
+
+    Args:
+        comment (str, optional): Comment included in unit.
+        subtype (str, optional): Defines the type of junction unit (*Should not be changed*)
+        labels (str, optional): Unlimited number of labels, the first of which is the name.
+
+    Returns:
+        JUNCTION: Flood Modeller JUNCTION Unit class object"""
+
+    _unit = "JUNCTION"
+
+    def _read(self, block: list[str]) -> None:
+        self.comment = self._remove_unit_name(block[0])
+        self._subtype = self._get_first_word(block[1])
+        self.labels = split_12_char(block[2])
+
+        self.name = self.labels[0]
+
+    def _write(self) -> list[str]:
+        _validate_unit(self)
+        return [
+            self._create_header(),
+            self.subtype,  # type: ignore
+            join_12_char_ljust(*self.labels).rstrip(),
+        ]
+
+    def _create_from_blank(
+        self,
+        comment: str = "",
+        subtype: str = "OPEN",
+        labels: list[str] | None = None,
+    ) -> None:
+        self.comment = comment
+        self._subtype = subtype
+        self.labels = labels if labels is not None else []
+        self.name = self.labels[0]
+
+
+class LATERAL(Unit):
+    """Class to hold and process LATERAL unit type
+
+    Args:
+        name (str, optional): Unit name.
+        comment (str, optional): Comment included in unit.
+        subtype (str, optional): Defines the type of lateral unit (*Should not be changed*)
+        weight_factor (str, optional): Corresponding weight factors or user-defined area for
+            each receiving unit
+        data (pandas.DataFrame): Dataframe object containing all the reservoir section data.
+            Columns are ``'Node Label', 'Custom Weight Factor', 'Use Weight Factor'``
+
+    Returns:
+        LATERAL: Flood Modeller LATERAL Unit class object"""
+
+    _unit = "LATERAL"
+
+    def _read(self, block: list[str]) -> None:
+        self.comment = self._remove_unit_name(block[0])
+        self.name = block[1]
+        self.weight_factor = block[2]
+        self.no_units = to_int(block[3])
+        self.data = read_lateral_data(block[4:])
+        self.labels = list(self.data["Node Label"])
+
+    def _write(self) -> list[str]:
+        _validate_unit(self)
+        return [
+            self._create_header(),
+            self.name,  # type: ignore
+            self.weight_factor,
+            *write_dataframe(self.no_units, self.data, n=12),
+        ]
+
+    def _create_from_blank(
+        self,
+        name: str = "new_junction",
+        comment: str = "",
+        subtype: str = "OPEN",
+        weight_factor: str = "REACH",
+        data: pd.DataFrame | None = None,
+    ) -> None:
+        self.name = name
+        self.comment = comment
+        self._subtype = subtype
+        self.weight_factor = weight_factor
+
+        self.data = self._enforce_dataframe(
+            data,
+            ("Node Label", "Custom Weight Factor", "Use Weight Factor"),
+        )
+        self.no_units = len(self.data)
+        self.labels = list(self.data["Node Label"])

floodmodeller_api/units/controls.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from floodmodeller_api.validation import _validate_unit
+
+from ._base import Unit
+from ._helpers import (
+    join_10_char,
+    join_12_char_ljust,
+    read_reservoir_data,
+    split_10_char,
+    split_12_char,
+    to_float,
+    to_int,
+    write_dataframe,
+)
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+
+class RESERVOIR(Unit):
+    """Class to hold and process RESERVOIR unit type
+
+    Args:
+        name (str, optional): Unit name.
+        comment (str, optional): Comment included in unit.
+        labels (str, optional): Unlimited number of labels - not including first label (name).
+        easting (float, optional): Easting coordinate of reservoir reference point (not used in computations).
+        northing (float, optional): Northing coordinate of reservoir reference point (not used in computations).
+        runoff_factor (float, optional): Rainfall runoff factor.
+        lateral_inflow_labels (list[str], optional): Lateral inflow labels (up to 4).
+        data (pandas.DataFrame): Dataframe object containing all the reservoir section data.
+            Columns are ``'Elevation','Plan Area'``
+
+    Returns:
+        RESERVOIR: Flood Modeller RESERVOIR Unit class object"""
+
+    _unit = "RESERVOIR"
+
+    def _read(self, block: list[str]) -> None:
+        self._revision, self.comment = self._get_revision_and_comment(block[0])
+
+        self.labels = split_12_char(block[1])
+        self.name = self.labels[0]
+
+        if self._revision == 1:
+            self.lateral_inflow_labels = split_12_char(block[2])
+            idx = 3
+
+            lines = split_10_char(f"{block[-1]:<30}")
+            self.easting = to_float(lines[0])
+            self.northing = to_float(lines[1])
+            self.runoff = to_float(lines[2])
+        else:
+            idx = 2
+
+        self.no_rows = to_int(block[idx])
+        start_idx = idx + 1
+        end_idx = start_idx + self.no_rows
+        self.data = read_reservoir_data(block[start_idx:end_idx])
+
+    def _write(self) -> list[str]:
+        _validate_unit(self)
+        rev1_a = (
+            [join_12_char_ljust(*self.lateral_inflow_labels).rstrip()]
+            if self._revision == 1
+            else []
+        )
+        rev1_b = (
+            [join_10_char(self.easting, self.northing, self.runoff)] if self._revision == 1 else []
+        )
+        return [
+            self._create_header(include_revision=self._revision is not None),
+            join_12_char_ljust(*self.labels).rstrip(),
+            *rev1_a,
+            *write_dataframe(self.no_rows, self.data),
+            *rev1_b,
+        ]
+
+    def _create_from_blank(  # noqa: PLR0913 (need that many)
+        self,
+        name: str = "new_reservoir",
+        comment: str = "",
+        subtype: str = "OPEN",
+        labels: list[str] | None = None,
+        easting: float = 0.0,
+        northing: float = 0.0,
+        runoff: float = 0.0,
+        lateral_inflow_labels: list[str] | None = None,
+        data: pd.DataFrame | None = None,
+    ) -> None:
+        self.easting = easting
+        self.northing = northing
+        self.runoff = runoff
+        self.name = name
+        self.comment = comment
+        self._subtype = subtype
+        self._revision = 1
+        self.labels = labels if labels is not None else []
+        self.lateral_inflow_labels = (
+            lateral_inflow_labels if lateral_inflow_labels is not None else []
+        )
+
+        self.data = self._enforce_dataframe(data, ("Elevation", "Plan Area"))
+        self.no_rows = len(self.data)