Patch: Fixed date maintenance timing and runaway processes (#205)

* drop duplicated request ids in process_times counting

* update changelog

* udpate request summary

* ensure default starting date is overridden, not specific

* minor port simplifcation, no logic changes

* ensure multiple subassemblies can be recreated easily

* fix bug in TTP reset logic so there aren't hidden processes

* update changelog

* bump version

Author: RHammond2

CHANGELOG.md

@@ -1,5 +1,24 @@
 # CHANGELOG
 
+## v0.11.2 - 9 July 2025
+
+- Fixes a bug primarily impacting tow-to-port scenarios where individual maintenance and failure
+  models are not being reset upon either replacement or following a tow-to-port repair under
+  certain conditions. This allows for these additional processes to be perpetuated throughout the lifecycle
+  of the simulation while succumbing to the same inital flaw, compounding the number of erroneously
+  additional events. The issue is resolved by the following:
+    1. Multiple subassemblies can now be passed to a `Cable` or `System` object during an
+       interruption, allowing for simpler logic handling.
+    2. TTP repairs no longer reset the subassemblies at the time of towing to port, and instead reset
+       the subassemblies after the turbine has been towed to site. Resetting in the final stage
+       ensures that any newly created processes, and especially fixed date maintenance schedules can
+       not create extra processes between tow, repair, and site return operations.
+- Fixes a bug in the `Metrics.process_times()` calculation inflating the count of total events
+  when cables are shut down. This is due to immediate logging of the upstream system and cables
+  shutting down with shared logging data.
+- Applies the same fix to the `Metrics.request_summary()` calculation, ensuring duplicated logging
+  messages are not caught up in the end result.
+
 ## v0.11.1 - 3 July 2025
 
 - Fixes a bug causing 25+ hour mooring connection operations to never complete due to shift delays

tests/unit/test_data_classes.py

@@ -619,9 +619,11 @@ def test_SubassemblyData():
     N_failure = len(failure_levels)
 
     subassembly = SubassemblyData.from_dict(GENERATOR_SUBASSEMBLY)
-    maintenance_list = [
-        Maintenance.from_dict(m) for m in GENERATOR_SUBASSEMBLY["maintenance"]
-    ]
+
+    # ensure subassembly level default start date gets passed through
+    start = {"start_date": GENERATOR_SUBASSEMBLY["maintenance_start"]}
+    maintenance_list = [start | m for m in GENERATOR_SUBASSEMBLY["maintenance"]]
+    maintenance_list = [Maintenance.from_dict(m) for m in maintenance_list]
     failure_list = [
         Failure.from_dict({**f, "rng": RNG}) for f in GENERATOR_SUBASSEMBLY["failures"]
     ]

wombat/__init__.py

@@ -4,4 +4,4 @@
 from wombat.core.library import create_library_structure, load_yaml
 
 
-__version__ = "0.11.1"
+__version__ = "0.11.2"

wombat/core/data_classes.py

@@ -490,10 +490,11 @@ def check_start_stop_dates(
 
 def convert_maintenance_list(value: list[dict], self_) -> list[Maintenance]:
     """Converts a list of ``Maintenance`` configuration dictionaries to a list of
-    ``Maintenance`` objects.
+    ``Maintenance`` objects, setting the ``start_date`` if it doesn't exist yet,
+    and adding the ``self_.system_value``.
     """
     kw = {"system_value": self_.system_value, "start_date": self_.maintenance_start}
-    [el.update(kw) for el in value]
+    value = [kw | el for el in value]
     return [Maintenance.from_dict(el) for el in value]
 
 

wombat/core/port.py

@@ -401,6 +401,7 @@ def run_tow_to_port(self, request: RepairRequest) -> Generator[Process]:
 
         system_id = request.system_id
         request_id = request.request_id
+        system = self.windfarm.system(system_id)
 
         # Double check in case a delay causes multiple vessels to be interacting with
         # the same turbine
@@ -410,15 +411,13 @@ def run_tow_to_port(self, request: RepairRequest) -> Generator[Process]:
         self.invalid_systems.append(system_id)
 
         # If the system is already undergoing repairs from other servicing equipment,
-        # then wait until it's done being serviced
-        servicing = self.windfarm.system(system_id).servicing
+        # then wait until it's done being serviced. Also wait for a spot to open up in
+        # the port queue
 
-        # Wait for a spot to open up in the port queue
         turbine_request = self.turbine_manager.request()
-
-        yield turbine_request & servicing
+        yield turbine_request & system.servicing
         yield self.env.timeout(self.env.get_random_seconds())
-        yield self.windfarm.system(system_id).servicing
+        yield system.servicing
 
         # Request a tugboat to retrieve the turbine
         tugboat = yield self.service_equipment_manager.get(

wombat/core/post_processor.py

@@ -2095,6 +2095,7 @@ def process_times(self, include_incompletes: bool = True) -> pd.DataFrame:
                 events_valid.action.isin(("repair request", "maintenance request")),
                 ["request_id", "env_time"],
             ]
+            .drop_duplicates(subset=["request_id"])
             .set_index("request_id")
             .sort_index()
         )
@@ -2151,26 +2152,30 @@ def request_summary(self) -> pd.DataFrame:
         requests = self.events.loc[
             self.events.action.isin(("repair request", "maintenance request")),
             "request_id",
-        ]
+        ].drop_duplicates()
         canceled_requests = self.events.loc[
             self.events.action.isin(("repair canceled", "maintenance canceled")),
             "request_id",
-        ]
+        ].drop_duplicates()
         completed_requests = self.events.loc[
             self.events.action.isin(("repair complete", "maintenance complete")),
             "request_id",
-        ]
+        ].drop_duplicates()
         incomplete_requests = requests.loc[
             ~requests.isin(canceled_requests) & ~requests.isin(completed_requests)
         ]
-        total_df = self.events.loc[
-            self.events.action.isin(("repair request", "maintenance request")),
-            ["part_name", "reason", "request_id"],
-        ].rename(
-            columns={
-                "part_name": "subassembly",
-                "reason": "task",
-            }
+        total_df = (
+            self.events.loc[
+                self.events.action.isin(("repair request", "maintenance request")),
+                ["part_name", "reason", "request_id"],
+            ]
+            .rename(
+                columns={
+                    "part_name": "subassembly",
+                    "reason": "task",
+                }
+            )
+            .drop_duplicates(subset=["request_id"])
         )
         canceled_df = (
             total_df.loc[total_df.request_id.isin(canceled_requests)]

wombat/core/repair_management.py

@@ -534,8 +534,27 @@ def invalidate_system(
                 self.systems_waiting_for_tow.index(system.id)
             )
 
+    def reset_subassembly_processes(
+        self, system: System | Cable, subassemblies: list[str]
+    ) -> None:
+        """Resets the specified failure and maintenance tasks for each of the
+        :py:attr:`subassemblies` in the :py:attr:`system`.
+
+        Parameters
+        ----------
+        system : System | Cable
+            The turbine, substation, electrolyzer, or cable needing to be interrupted
+            with specified :py:attr:`subassemblies` processes reset.
+        subassemblies : list[str]
+            The list of subassemblies to have their failure and maintenance models
+            recreated (replacement or tow-to-port events only).
+        """
+        system.interrupt_all_subassembly_processes(subassembly_full_reset=subassemblies)
+
     def interrupt_system(
-        self, system: System | Cable, replacement: str | None = None
+        self,
+        system: System | Cable,
+        subassembly_full_reset: str | list[str] | None = None,
     ) -> None:
         """Sets the turbine status to be in servicing, and interrupts all the processes
         to turn off operations.
@@ -544,13 +563,19 @@ def interrupt_system(
         ----------
         system_id : str
             The system to disable repairs.
-        replacement: str | None, optional
-            If a subassebly `id` is provided, this indicates the interruption is caused
-            by its replacement event. Defaults to None.
+        subassembly_full_reset: str | list[str] | None, optional
+            If a subassebly `id` is provided, this indicates the interruption will
+            cancel the current maintenance and failure modes, then recreate the
+            replacement or tow-to-port repair is completed. Defaults to None.
         """
+        if subassembly_full_reset is None:
+            subassembly_full_reset = []
+        if isinstance(subassembly_full_reset, str):
+            subassembly_full_reset = [subassembly_full_reset]
+
         if system.servicing.triggered and system.id in self.invalid_systems:
             system.servicing = self.env.event()
-            system.interrupt_all_subassembly_processes(replacement=replacement)
+            self.reset_subassembly_processes(system, subassembly_full_reset)
         else:
             raise RuntimeError(
                 f"{self.env.simulation_time} {system.id} already being serviced"

wombat/core/service_equipment.py

@@ -144,8 +144,11 @@ def reset_system_operations(system: System, subassembly_resets: list[str]) -> No
         The ``subassembly_id`` to reset to good as new, if not assuming all
         subassemblies.
     """
+    system.interrupt_all_subassembly_processes(
+        subassembly_full_reset=subassembly_resets
+    )
     for subassembly in system.subassemblies:
-        if subassembly.name in subassembly_resets:
+        if subassembly.id in subassembly_resets:
             subassembly.operating_level = 1.0
             subassembly.recreate_processes()
 
@@ -1494,7 +1497,7 @@ def in_situ_repair(
             replacement = (
                 request.subassembly_id if request.details.replacement else None
             )
-            self.manager.interrupt_system(system, replacement=replacement)
+            self.manager.interrupt_system(system, subassembly_full_reset=replacement)
         yield self.env.process(
             self.crew_transfer(system, subassembly, request, to_system=True)
         )
@@ -1916,8 +1919,7 @@ def run_tow_to_port(self, request: RepairRequest) -> Generator[Process]:
         )
 
         # Turn off the turbine
-        replacement = request.subassembly_id if request.details.replacement else None
-        self.manager.interrupt_system(system, replacement=replacement)
+        self.manager.interrupt_system(system)
 
         # Unmoor the turbine and tow it back to port
         yield self.env.process(self.mooring_connection(system, request, which="unmoor"))
@@ -1972,7 +1974,6 @@ def run_tow_to_site(
             self.mooring_connection(system, request, which="reconnect")
         )
 
-        # Reset the turbine back to operating and return to port
         reset_system_operations(system, subassembly_resets)
         self.manager.enable_requests_for_system(system, tow=True)
         yield self.env.process(

wombat/windfarm/system/cable.py

@@ -195,20 +195,20 @@ def recreate_processes(self) -> None:
         """
         self.processes = dict(self._create_processes())
 
-    def interrupt_processes(self, replacement: str | None = None) -> None:
+    def interrupt_processes(self, subassembly_full_reset: list[str]) -> None:
         """Interrupts all of the running processes within the subassembly except for the
         process associated with failure that triggers the catastrophic failure.
 
         Parameters
         ----------
         subassembly : Subassembly
             The subassembly that should have all processes interrupted.
-        replacement: bool, optional
-            If a subassebly `id` is provided, this indicates the interruption is caused
-            by its replacement event. Defaults to None.
+        subassembly_full_reset: list[str]
+            List of all subassebly `id` that will get a full reset of their simulated
+            failure and maintenance processes by a replacement or tow-to-port event.
         """
         cause = "failure"
-        if self.id == replacement:
+        if self.id in subassembly_full_reset:
             cause = "replacement"
 
         for _, process in self.processes.items():
@@ -219,17 +219,21 @@ def interrupt_processes(self, replacement: str | None = None) -> None:
                 pass
 
     def interrupt_all_subassembly_processes(
-        self, replacement: str | None = None
+        self, subassembly_full_reset: list[str] | None = None
     ) -> None:
         """Thin wrapper for ``interrupt_processes`` for consistent usage with system.
 
         Parameters
         ----------
-        replacement: bool, optional
-            If a subassebly `id` is provided, this indicates the interruption is caused
-            by its replacement event. Defaults to None.
+        subassembly_full_reset: list[str] | None, optional
+            List of all subassebly `id` that will get a full reset of their simulated
+            failure and maintenance processes by a replacement or tow-to-port event.
+            Defaults to None.
         """
-        self.interrupt_processes(replacement=replacement)
+        subassembly_full_reset = (
+            [] if subassembly_full_reset is None else subassembly_full_reset
+        )
+        self.interrupt_processes(subassembly_full_reset=subassembly_full_reset)
 
     def stop_all_upstream_processes(self, failure: Failure | Maintenance) -> None:
         """Stops all upstream turbines and cables from producing power by creating a

wombat/windfarm/system/subassembly.py

@@ -104,7 +104,9 @@ def recreate_processes(self) -> None:
         self.processes = dict(self._create_processes())
 
     def interrupt_processes(
-        self, origin: Subassembly | None = None, replacement: str | None = None
+        self,
+        origin: Subassembly | None = None,
+        subassembly_full_reset: list[str] | None = None,
     ) -> None:
         """Interrupts all of the running processes within the subassembly except for the
         process associated with failure that triggers the catastrophic failure.
@@ -116,14 +118,17 @@ def interrupt_processes(
             from a subassembly shutdown event. If provided, and it is the same as the
             current subassembly, then a try/except flow is used to ensure the process
             that initiated the shutdown is not interrupting itself.
-        replacement: bool, optional
-            If a subassebly `id` is provided, this indicates the interruption is caused
-            by its replacement event. Defaults to None.
+        subassembly_full_reset: list[str]
+            List of all subassebly `id` that will get a full reset of their simulated
+            failure and maintenance processes by a replacement or tow-to-port event.
+            Defaults to None.
         """
+        subassembly_full_reset = (
+            [] if subassembly_full_reset is None else subassembly_full_reset
+        )
         cause = "failure"
-        if self.id == replacement:
+        if self.id in subassembly_full_reset:
             cause = "replacement"
-        # if origin is not None and id(origin) == id(self):
 
         # Processes that initiate the process can't be interrupted, nor can replaced
         # (already cancelled) processes