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

floodmodeller_api/test/test_river.py

@@ -0,0 +1,169 @@
+import pandas as pd
+import pytest
+
+from floodmodeller_api.units.sections import RIVER
+
+river_unit_data_cases = [
+    (
+        [
+            "RIVER normal case",
+            "SECTION",
+            "SomeUnit",
+            "     0.000            0.000100  1000.000",
+            "        5",
+            "     0.000        10     0.030     0.000                 0.0       0.0          ",
+            "     1.000         9     0.030     0.000                 0.0       0.0      LEFT",
+            "     2.000         5     0.030     0.000                 0.0       0.0          ",
+            "     3.000         6     0.030     0.000                 0.0       0.0     RIGHT",
+            "     4.000        10     0.030     0.000                 0.0       0.0          ",
+        ],
+        3,
+    ),
+    (
+        [
+            "RIVER close together",
+            "SECTION",
+            "AnotherUnit",
+            "     0.000            0.000100  1000.000",
+            "        3",
+            "     0.000        15     0.040     0.000                 0.0       0.0          ",
+            "     1.500         8     0.040     0.000                 0.0       0.0      LEFT",
+            "     3.000        12     0.040     0.000                 0.0       0.0     RIGHT",
+        ],
+        2,
+    ),
+    (
+        [
+            "RIVER double markers",
+            "SECTION",
+            "AnotherUnit",
+            "     0.000            0.000100  1000.000",
+            "        3",
+            "     0.000        15     0.040     0.000                 0.0       0.0          ",
+            "     1.500         8     0.040     0.000                 0.0       0.0      LEFT",
+            "     3.000        12     0.040     0.000                 0.0       0.0          ",
+            "     4.000        13     0.040     0.000                 0.0       0.0      LEFT",
+            "     5.000         2     0.040     0.000                 0.0       0.0          ",
+            "     6.000         1     0.040     0.000                 0.0       0.0          ",
+            "     7.000       254     0.040     0.000                 0.0       0.0     RIGHT",
+            "     8.000        21     0.040     0.000                 0.0       0.0          ",
+            "     9.000        76     0.040     0.000                 0.0       0.0     RIGHT",
+        ],
+        4,
+    ),
+]
+
+
+@pytest.mark.parametrize(("river_unit_data", "_"), river_unit_data_cases)
+def test_read_write(river_unit_data, _):
+    river_section_1 = RIVER(river_unit_data)
+    river_section_2 = RIVER(river_section_1._write())
+    assert river_section_1 == river_section_2
+
+
+@pytest.mark.parametrize(("river_unit_data", "expected_len"), river_unit_data_cases)
+def test_river_active_data(river_unit_data, expected_len):
+    river_section = RIVER(river_unit_data)
+    active_data = river_section.active_data
+
+    assert len(active_data) == expected_len
+    assert active_data.iloc[0].Deactivation == "LEFT"
+    assert active_data.iloc[-1].Deactivation == "RIGHT"
+    assert "LEFT" not in active_data.iloc[1:-1].Deactivation.to_list()
+    assert "RIGHT" not in active_data.iloc[1:-1].Deactivation.to_list()
+
+
+def test_edit_active_data():
+    unit = RIVER(
+        [
+            "RIVER normal case",
+            "SECTION",
+            "SomeUnit",
+            "     0.000            0.000100  1000.000",
+            "        5",
+            "     0.000        10     0.030     0.000                 0.0       0.0          ",
+            "     1.000         9     0.030     0.000                 0.0       0.0      LEFT",
+            "     2.000         5     0.030     0.000                 0.0       0.0          ",
+            "     3.000         6     0.030     0.000                 0.0       0.0     RIGHT",
+            "     4.000        10     0.030     0.000                 0.0       0.0          ",
+        ],
+    )
+    unit.active_data.iloc[0, 1] = 99
+    assert unit.data.iloc[1, 1] == 99
+    expected_row = "1.000    99.000     0.030     0.000               0.000     0.000      LEFT"
+    assert expected_row in str(unit)
+
+
+def test_active_data_with_no_markers():
+    unit = RIVER(
+        [
+            "RIVER normal case",
+            "SECTION",
+            "SomeUnit",
+            "     0.000            0.000100  1000.000",
+            "        5",
+            "     0.000        10     0.030",
+            "     1.000         9     0.030",
+            "     2.000         5     0.030",
+            "     3.000         6     0.030",
+            "     4.000        10     0.030",
+        ],
+    )
+    assert len(unit.active_data) == 5
+    unit.data.iloc[1, 8] = "LEFT"
+    unit.data.iloc[3, 8] = "RIGHT"
+    assert len(unit.active_data) == 3
+
+
+def test_create_from_blank():
+    blank_unit = RIVER()
+    assert len(blank_unit.data) == 0
+    assert len(blank_unit.active_data) == 0
+    assert blank_unit._write() == [
+        "RIVER ",
+        "SECTION",
+        "new_section                                                                         ",
+        "     0.000            0.000100  1000.000",
+        "         0",
+    ]
+
+
+def test_create_from_blank_with_params():
+    unit = RIVER(
+        name="for_test",
+        comment="testing",
+        spill1="t",
+        spill2="e",
+        lat1="s",
+        lat2="t",
+        lat3="i",
+        lat4="ng",
+        dist_to_next=55,
+        slope=0.00015,
+        density=1010.0,
+        data=pd.DataFrame(
+            {
+                "X": [0.0, 1.0, 2.0],
+                "Y": [5.0, 2.0, 5.0],
+                "Mannings n": [0.01, 0.01, 0.01],
+                "Panel": ["", "", ""],
+                "RPL": [0.0, 0.0, 0.0],
+                "Marker": ["", "", ""],
+                "Easting": [0.0, 0.0, 0.0],
+                "Northing": [0.0, 0.0, 0.0],
+                "Deactivation": ["", "", ""],
+                "SP. Marker": ["", "", ""],
+            },
+        ),
+    )
+
+    assert unit._write() == [
+        "RIVER testing",
+        "SECTION",
+        "for_test    t           e           s           t           i           ng          ",
+        "    55.000            0.000150  1010.000",
+        "         3",
+        "     0.000     5.000     0.010     0.000               0.000     0.000                    ",
+        "     1.000     2.000     0.010     0.000               0.000     0.000                    ",
+        "     2.000     5.000     0.010     0.000               0.000     0.000                    ",
+    ]

floodmodeller_api/to_from_json.py

@@ -77,6 +77,7 @@ def recursive_to_json(obj: Any, is_top_level: bool = True) -> Any:  # noqa: PLR0
     """
     from ._base import FMFile
     from .backup import File
+    from .ief import FlowTimeProfile
     from .units import IIC
     from .units._base import Unit
     from .urban1d._base import UrbanSubsection, UrbanUnit
@@ -105,7 +106,10 @@ def recursive_to_json(obj: Any, is_top_level: bool = True) -> Any:  # noqa: PLR0
         return {key: recursive_to_json(value, is_top_level=False) for key, value in obj.items()}
 
     # Either a type of FM API Class
-    if isinstance(obj, (FMFile, Unit, IIC, File, UrbanSubsection, UrbanUnit)):  # noqa: RET503
+    if isinstance(
+        obj,
+        (FMFile, Unit, IIC, File, UrbanSubsection, UrbanUnit, FlowTimeProfile),
+    ):
         # Information from the flood modeller object will be included in the JSON output
         # slicing undertaken to remove quotation marks
         return_dict: dict[str, Any] = {"API Class": str(obj.__class__)[8:-2]}
@@ -118,6 +122,8 @@ def recursive_to_json(obj: Any, is_top_level: bool = True) -> Any:  # noqa: PLR0
 
         return return_dict
 
+    return None
+
 
 def from_json(obj: str | dict) -> dict:
     """

floodmodeller_api/tool.py

@@ -54,9 +54,7 @@ def validate_int(value):
     """
     if value.isdigit():
         return True
-    if value == "":
-        return True
-    return False
+    return value == ""
 
 
 def validate_float(value):
@@ -72,9 +70,7 @@ def validate_float(value):
         float(value)
         return True
     except ValueError:
-        if value == "":
-            return True
-        return False
+        return value == ""
 
 
 class Gui:
@@ -92,7 +88,7 @@ class Gui:
 
     """
 
-    def __init__(  # noqa: PLR0913
+    def __init__(
         self,
         master: tk.Tk,
         title: str,
@@ -145,12 +141,12 @@ class Gui:
             label.pack()
             # Conditional stuff to add validation for different data types.
             # This ensures that you can't enter text if the input should be a number, etc.
-            if data_type == str:
+            if data_type is str:
                 entry = tk.Entry(self.master)
-            elif data_type == int:
+            elif data_type is int:
                 entry = tk.Entry(self.master, validate="key")
                 entry.config(validatecommand=(entry.register(validate_int), "%P"))
-            elif data_type == float:
+            elif data_type is float:
                 entry = tk.Entry(self.master, validate="key")
                 entry.config(validatecommand=(entry.register(validate_float), "%P"))
             else:

floodmodeller_api/units/__init__.py

@@ -4,7 +4,17 @@ from .conduits import CONDUIT
 from .iic import IIC
 from .losses import BLOCKAGE, CULVERT
 from .sections import INTERPOLATE, REPLICATE, RIVER
-from .structures import BRIDGE, CRUMP, FLAT_V_WEIR, ORIFICE, OUTFALL, RNWEIR, SLUICE, SPILL, WEIR
+from .structures import (
+    BRIDGE,
+    CRUMP,
+    FLAT_V_WEIR,
+    ORIFICE,
+    OUTFALL,
+    RNWEIR,
+    SLUICE,
+    SPILL,
+    WEIR,
+)
 from .units import ALL_UNIT_TYPES, SUPPORTED_UNIT_TYPES, UNSUPPORTED_UNIT_TYPES
 from .unsupported import UNSUPPORTED
 from .variables import Variables

floodmodeller_api/units/conveyance.py

@@ -1,31 +1,34 @@
 from __future__ import annotations
 
 from functools import lru_cache
+from typing import TYPE_CHECKING
 
 import numpy as np
 import pandas as pd
-from shapely import LineString, MultiLineString, Polygon, intersection
+
+if TYPE_CHECKING:
+    from numpy.typing import NDArray
 
 MINIMUM_PERIMETER_THRESHOLD = 1e-8
 
 
 def calculate_cross_section_conveyance(
-    x: np.ndarray,
-    y: np.ndarray,
-    n: np.ndarray,
-    rpl: np.ndarray,
-    panel_markers: np.ndarray,
+    x: NDArray[np.float64],
+    y: NDArray[np.float64],
+    n: NDArray[np.float64],
+    rpl: NDArray[np.float64],
+    panel_markers: NDArray[np.float64],
 ) -> pd.Series:
     """
     Calculate the conveyance of a cross-section by summing the conveyance
     across all panels defined by panel markers.
 
     Args:
-        x (np.ndarray): The x-coordinates of the cross-section.
-        y (np.ndarray): The y-coordinates of the cross-section.
-        n (np.ndarray): Manning's n values for each segment.
-        rpl (np.ndarray): Relative Path Length values for each segment.
-        panel_markers (np.ndarray): Boolean array indicating the start of each panel.
+        x (NDArray[np.float64]): The x-coordinates of the cross-section.
+        y (NDArray[np.float64]): The y-coordinates of the cross-section.
+        n (NDArray[np.float64]): Manning's n values for each segment.
+        rpl (NDArray[np.float64]): Relative Path Length values for each segment.
+        panel_markers (NDArray[np.float64]): Boolean array indicating the start of each panel.
 
     Returns:
         pd.Series: A pandas Series containing the conveyance values indexed by water levels.
@@ -41,164 +44,115 @@ def calculate_cross_section_conveyance(
             result = calculate_cross_section_conveyance(x, y, n, rpl, panel_markers)
             print(result)
     """
-    # Create a set of water levels to calculate conveyance at,
-    # currently using 50mm minimum increments plus WLs at every data point
-    wls = insert_intermediate_wls(np.unique(y), threshold=0.05)
-
-    # Panel markers are forced true to the bounds to make the process work
-    panel_markers = np.array([True, *panel_markers[1:-1], True])
-    panel_indices = np.where(panel_markers)[0]
-    conveyance_by_panel = []
-    for panel_start, panel_end in zip(panel_indices[:-1], panel_indices[1:] + 1):
-        panel_x = x[panel_start:panel_end]
-        panel_y = y[panel_start:panel_end]
-        panel_n = n[panel_start:panel_end]
-        # RPL value is only valid for the start of a panel, and set to 1 if it's zero
-        panel_rpl = (
-            1.0
-            if (panel_start == 0 and not panel_markers[0]) or rpl[panel_start] == 0
-            else float(rpl[panel_start])
-        )
-        conveyance_by_panel.append(
-            calculate_conveyance_by_panel(panel_x, panel_y, panel_n, panel_rpl, wls),
-        )
-
-    # Sum conveyance across panels
-    conveyance_values = [sum(values) for values in zip(*conveyance_by_panel)]
-
-    return pd.Series(data=conveyance_values, index=wls)
-
-
-def calculate_conveyance_by_panel(
-    x: np.ndarray,
-    y: np.ndarray,
-    n: np.ndarray,
-    rpl: float,
-    wls: np.ndarray,
-) -> list[float]:
-    """
-    Calculate the conveyance for a single panel of a cross-section at specified water levels.
-
-    Args:
-        x (np.ndarray): The x-coordinates of the panel.
-        y (np.ndarray): The y-coordinates of the panel.
-        n (np.ndarray): Manning's n values for each segment in the panel.
-        rpl (float): Relative Path Length for each segment in the panel.
-        wls (np.ndarray): The water levels at which to calculate conveyance.
-
-    Returns:
-        list[float]: A list of conveyance values for each water level.
-    """
+    water_levels = insert_intermediate_wls(np.unique(y), threshold=0.05)
+    area, length, mannings = calculate_geometry(x, y, n, water_levels)
+    panel = panel_markers.cumsum()[:-1]
 
-    max_y = np.max(wls) + 1
-    min_y = np.min(wls) - 1
+    intersection = (y[:-2] < water_levels[:, np.newaxis]) & (y[1:-1] >= water_levels[:, np.newaxis])
+    section_markers = np.hstack([np.full((intersection.shape[0], 1), False), intersection])
+    section = section_markers.cumsum(axis=1)
 
-    # insert additional start/end points to represent the glass wall sides
-    x = np.array([x[0], *x, x[-1]])
-    y = np.array([max_y, *y, max_y])
-    n = np.array([0, *n, 0])
+    conveyance = np.zeros_like(water_levels)
 
-    # Define a polygon for the channel including artificial sides and top
-    channel_polygon = Polygon(zip(x, y))
-    start, end = x[0] - 0.1, x[-1] + 0.1  # Useful points enclosing the x bounds with small buffer
-
-    # Define linestring geometries representing glass walls, so they can be subtracted later
-    glass_walls = (
-        LineString(zip([x[0], x[1]], [y[0], y[1]])),  # left
-        LineString(zip([x[-2], x[-1]], [y[-2], y[-1]])),  # right
-    )
-
-    # Remove glass wall sections from coords
-    x, y, n = x[1:-1], y[1:-1], n[1:-1]
-
-    conveyance_values = []
-    for wl in wls:
-        if wl <= np.min(y):
-            # no channel capacity (essentially zero depth) so no need to calculate
-            conveyance_values.append(0.0)
+    for i in range(panel.max() + 1):
+        in_panel = panel == i
+        if not in_panel.any():
             continue
 
-        # Some geometries to represent the channel at a given water level
-        water_surface = Polygon(zip([start, start, end, end], [wl, min_y, min_y, wl]))
-        water_plane = intersection(channel_polygon, LineString(zip([start, end], [wl, wl])))
-        wetted_polygon = intersection(channel_polygon, water_surface)
+        rpl_panel = np.sqrt(rpl[:-1][in_panel][0])
+        rpl_panel = 1 if rpl_panel == 0 else rpl_panel
 
-        multiple_parts = wetted_polygon.geom_type in ["GeometryCollection", "MultiPolygon"]
-        parts = wetted_polygon.geoms if multiple_parts else [wetted_polygon]
+        for j in range(section.max() + 1):
+            in_section = section == j
+            in_panel_and_section = in_panel & in_section
+            if not in_panel_and_section.any():
+                continue
 
-        conveyance = 0.0
+            total_area = np.where(in_panel_and_section, area, 0).sum(axis=1)
+            total_length = np.where(in_panel_and_section, length, 0).sum(axis=1)
+            total_mannings = np.where(in_panel_and_section, mannings, 0).sum(axis=1)
 
-        # 'parts' here refers to when a water level results in 2 separate channel sections,
-        # e.g. where the cross section has a 'peak' part way through
-        for part in parts:
-            conveyance += calculate_conveyance_part(part, water_plane, glass_walls, x, n, rpl)
-        conveyance_values.append(conveyance)
+            conveyance += np.where(
+                total_length >= MINIMUM_PERIMETER_THRESHOLD,
+                total_area ** (5 / 3) * total_length ** (1 / 3) / (total_mannings * rpl_panel),
+                0,
+            )
 
-    return conveyance_values
+    return pd.Series(conveyance, index=water_levels)
 
 
-def calculate_conveyance_part(  # noqa: PLR0913
-    wetted_polygon: Polygon,
-    water_plane: LineString,
-    glass_walls: tuple[LineString, LineString],
-    x: np.ndarray,
-    n: np.ndarray,
-    rpl: float,
-) -> float:
+def calculate_geometry(
+    x: NDArray[np.float64],
+    y: NDArray[np.float64],
+    n: NDArray[np.float64],
+    water_levels: NDArray[np.float64],
+) -> tuple[NDArray[np.float64], NDArray[np.float64], NDArray[np.float64]]:
     """
-    Calculate the conveyance for a part of the wetted area.
+    Calculate area, length, weighted mannings for piecewise linear curve (x, y) below water_level.
 
     Args:
-        wetted_polygon (Polygon): The polygon representing the wetted area.
-        water_plane (LineString): The line representing the water plane.
-        glass_wall_left (LineString): The left boundary of the channel.
-        glass_wall_right (LineString): The right boundary of the channel.
-        x (np.ndarray): 1D array of channel chainage
-        n (np.ndarray): 1D array of channel mannings
-        rpl (float): Relative path length of panel
+        x (NDArray[np.float64]): 1D array of x-coordinates.
+        y (NDArray[np.float64]): 1D array of y-coordinates.
+        n (NDArray[np.float64]): 1D array to integrate over the length.
+        water_levels (NDArray[np.float64]): The horizontal reference line.
 
     Returns:
-        float: The conveyance value for the wetted part.
+        NDArray[np.float64]: The area above the curve and under the reference line.
+        NDArray[np.float64]: The length of the curve under the reference line.
+        NDArray[np.float64]: Manning's n integrated along the curve under the reference line.
     """
-    water_plane_clip: LineString = intersection(water_plane, wetted_polygon)
-    glass_wall_left_clip: LineString = intersection(glass_walls[0], wetted_polygon)
-    glass_wall_right_clip: LineString = intersection(glass_walls[1], wetted_polygon)
-
-    # wetted perimeter should only account for actual section of channel, so we need to remove any
-    # length related to the water surface and any glass walls due to panel
-    perimeter_loss = (
-        water_plane_clip.length + glass_wall_left_clip.length + glass_wall_right_clip.length
+    h = water_levels[:, np.newaxis] - y
+
+    x1 = x[:-1]
+    x2 = x[1:]
+    h1 = h[:, :-1]
+    h2 = h[:, 1:]
+    n1 = n[:-1]
+
+    dx = x2 - x1
+
+    is_submerged = (h1 > 0) & (h2 > 0)
+    is_submerged_on_left = (h1 > 0) & (h2 <= 0)
+    is_submerged_on_right = (h1 <= 0) & (h2 > 0)
+    conditions = [is_submerged, is_submerged_on_left, is_submerged_on_right]
+
+    # needed for partially submerged sections
+    dx_left = dx * h1 / (h1 - h2)
+    dx_right = dx * h2 / (h2 - h1)
+
+    area = np.select(
+        conditions,
+        [
+            0.5 * dx * (h1 + h2),
+            0.5 * dx_left * h1,
+            0.5 * dx_right * h2,
+        ],
+        default=0,
     )
-
-    wetted_perimeter = wetted_polygon.boundary.length - perimeter_loss
-    if wetted_perimeter < MINIMUM_PERIMETER_THRESHOLD:
-        # Would occur if water level is above lowest point on section, but intersects a near-zero
-        # perimeter, e.g. touching the bottom of an elevated side channel
-        return 0.0
-
-    area = wetted_polygon.area
-
-    wetted_polyline: LineString = (
-        wetted_polygon.exterior.difference(water_plane_clip)
-        .difference(glass_wall_left_clip)
-        .difference(glass_wall_right_clip)
+    length = np.select(
+        conditions,
+        [
+            np.sqrt((h2 - h1) ** 2 + dx**2),
+            np.sqrt(h1**2 + dx_left**2),
+            np.sqrt(h2**2 + dx_right**2),
+        ],
+        default=0,
     )
-    weighted_mannings = calculate_weighted_mannings(x, n, rpl, wetted_polyline)
+    weighted_mannings = n1 * length
 
-    # apply conveyance equation
-    return (area ** (5 / 3) / wetted_perimeter ** (2 / 3)) * (wetted_perimeter / weighted_mannings)
+    return area, length, weighted_mannings
 
 
-def insert_intermediate_wls(arr: np.ndarray, threshold: float):
+def insert_intermediate_wls(arr: NDArray[np.float64], threshold: float) -> NDArray[np.float64]:
     """
     Insert intermediate water levels into an array based on a threshold.
 
     Args:
-        arr (np.ndarray): The array of original water levels.
+        arr (NDArray[np.float64]): The array of original water levels.
         threshold (float): The maximum allowed gap between water levels.
 
     Returns:
-        np.ndarray: The array with intermediate water levels inserted.
+        NDArray[np.float64]: The array with intermediate water levels inserted.
     """
     # Calculate gaps between consecutive elements
     gaps = np.diff(arr)
@@ -207,81 +161,16 @@ def insert_intermediate_wls(arr: np.ndarray, threshold: float):
     num_points = (gaps // threshold).astype(int)
 
     # Prepare lists to hold the new points and results
-    new_points = []
-
-    for i, start in enumerate(arr[:-1]):
-        end = arr[i + 1]
-        if num_points[i] > 0:
-            points = np.linspace(start, end, num_points[i] + 2)[1:-1]
-            new_points.extend(points)
-        new_points.append(end)
-
-    # Combine the original starting point with the new points
-    return np.array([arr[0]] + new_points)
-
-
-def calculate_weighted_mannings(
-    x: np.ndarray,
-    n: np.ndarray,
-    rpl: float,
-    wetted_polyline: LineString,
-) -> float:
-    """Calculate the weighted Manning's n value for a wetted polyline."""
-
-    # We want the polyline to be split into each individual segment
-    segments = line_to_segments(wetted_polyline)
-    weighted_mannings = 0
-    for segment in segments:
-        mannings_value = get_mannings_by_segment_x_coords(
-            x,
-            n,
-            segment.coords[0][0],
-            segment.coords[1][0],
-        )
-        weighted_mannings += mannings_value * segment.length * np.sqrt(rpl)
-
-    return weighted_mannings
-
-
-def line_to_segments(line: LineString | MultiLineString) -> list[LineString]:
-    """Convert a LineString or MultiLineString into a list of LineString segments."""
-    if isinstance(line, LineString):
-        segments = []
-        for start, end in zip(line.coords[:-1], line.coords[1:]):
-            points = sorted([start, end], key=lambda x: x[0])
-            segments.append(LineString(points))
-        return segments
-    if isinstance(line, MultiLineString):
-        segments = []
-        for linestring in line.geoms:
-            segments.extend(line_to_segments(linestring))
-        return segments
-    raise TypeError("Input must be a LineString or MultiLineString")
-
-
-def get_mannings_by_segment_x_coords(
-    x: np.ndarray,
-    n: np.ndarray,
-    start_x: float,
-    end_x: float,
-) -> float:
-    """Get the Manning's n or RPL value for a segment based on its start x-coordinate."""
-
-    # This method doesn't handle cases where we have multiple manning's values at a vertical section
-    # and will always just take the first at any verticle, but it is probably quite rare for this
-    # not to be the case
-    if start_x == end_x:
-        # Vertical segment take first x match
-        index = np.searchsorted(x, start_x) - (start_x not in x)
-    else:
-        # Otherwise non-vertical segment, take last match
-        index = np.searchsorted(x, start_x, side="right") - 1
-
-    return n[index]
+    new_points = [
+        np.linspace(start, end, num + 2, endpoint=False)
+        for start, end, num in zip(arr[:-1], arr[1:], num_points)
+    ]
+    end = np.array([arr[-1]])
+    return np.concatenate([*new_points, end])
 
 
 @lru_cache
-def calculate_cross_section_conveyance_chached(
+def calculate_cross_section_conveyance_cached(
     x: tuple[float],
     y: tuple[float],
     n: tuple[float],