epyt-flow 0.7.3__py3-none-any.whl → 0.8.0__py3-none-any.whl

epyt_flow/VERSION

@@ -1 +1 @@
-0.7.3
+0.8.0

epyt_flow/gym/scenario_control_env.py

@@ -1,12 +1,15 @@
 """
 Module provides a base class for control environments.
 """
+import os
+import uuid
 from abc import abstractmethod, ABC
 from typing import Union
 import warnings
 import numpy as np
 
-from ..simulation import ScenarioSimulator, ScenarioConfig, ScadaData
+from ..simulation import ScenarioSimulator, ScenarioConfig, ScadaData, ToolkitConstants
+from ..utils import get_temp_folder
 
 
 class ScenarioControlEnv(ABC):
@@ -21,12 +24,32 @@ class ScenarioControlEnv(ABC):
         If True, environment is automatically reset if terminated.
 
         The default is False.
+
+    Attributes
+    ----------
+    _scenario_sim : :class:`~epyt_flow.simulation.scenario_simulator.ScenarioSimulator`, protected
+        Scenario simulator of the control scenario.
+    _scenario_config : :class:`~epyt_flow.simulation.scenario_config.ScenarioConfig`
+        Scenario configuration.
+    _sim_generator : Generator[Union[:class:`~epyt_flow.simulation.scada.scada_data.ScadaData`, dict], bool, None], protected
+        Generator for running the step-wise simulation.
+    _hydraulic_scada_data : :class:`~epyt_flow.simulation.scada.scada_data.ScadaData`, protected
+        SCADA data from the hydraulic simulation -- only used if EPANET-MSX is used in the control scenario.
     """
     def __init__(self, scenario_config: ScenarioConfig, autoreset: bool = False, **kwds):
-        self.__scenario_config = scenario_config
+        if not isinstance(scenario_config, ScenarioConfig):
+            raise TypeError("'scenario_config' must be an instance of " +
+                            "'epyt_flow.simulation.ScenarioConfig' " +
+                            "but not of '{type(scenario_config)}'")
+        if not isinstance(autoreset, bool):
+            raise TypeError("'autoreset' must be an instance of 'bool' " +
+                            f"but not of '{type(autoreset)}'")
+
+        self._scenario_config = scenario_config
         self._scenario_sim = None
         self._sim_generator = None
         self.__autoreset = autoreset
+        self._hydraulic_scada_data = None
 
         super().__init__(**kwds)
 
@@ -54,15 +77,27 @@ class ScenarioControlEnv(ABC):
         """
         try:
             if self._sim_generator is not None:
-                self._sim_generator.send(True)
                 next(self._sim_generator)
+                self._sim_generator.send(True)
         except StopIteration:
             pass
 
         if self._scenario_sim is not None:
             self._scenario_sim.close()
 
-    def reset(self) -> ScadaData:
+    def contains_events(self) -> bool:
+        """
+        Check if the scenario contains any events.
+
+        Returns
+        -------
+        `bool`
+            True is the scenario contains any events, False otherwise.
+        """
+        return len(self._scenario_config.system_events) != 0 or \
+            len(self._scenario_config.sensor_reading_events) != 0
+
+    def reset(self) -> Union[tuple[ScadaData, bool], ScadaData]:
         """
         Resets the environment (i.e. simulation).
 
@@ -75,20 +110,38 @@ class ScenarioControlEnv(ABC):
             self._scenario_sim.close()
 
         self._scenario_sim = ScenarioSimulator(
-            scenario_config=self.__scenario_config)
-        self._sim_generator = self._scenario_sim.run_simulation_as_generator(support_abort=True)
+            scenario_config=self._scenario_config)
+
+        if self._scenario_sim.f_msx_in is not None:
+            # Run hydraulic simulation first
+            hyd_export = os.path.join(get_temp_folder(), f"epytflow_env_MSX_{uuid.uuid4()}.hyd")
+            sim = self._scenario_sim.run_hydraulic_simulation
+            self._hydraulic_scada_data = sim(hyd_export=hyd_export)
+
+            # Run advanced quality analysis (EPANET-MSX) on top of the computed hydraulics
+            gen = self._scenario_sim.run_advanced_quality_simulation_as_generator
+            self._sim_generator = gen(hyd_export, support_abort=True)
+        else:
+            gen = self._scenario_sim.run_hydraulic_simulation_as_generator
+            self._sim_generator = gen(support_abort=True)
 
         return self._next_sim_itr()
 
-    def _next_sim_itr(self) -> ScadaData:
+    def _next_sim_itr(self) -> Union[tuple[ScadaData, bool], ScadaData]:
         try:
             next(self._sim_generator)
-            r = self._sim_generator.send(False)
+            scada_data = self._sim_generator.send(False)
+
+            if self._scenario_sim.f_msx_in is not None:
+                cur_time = int(scada_data.sensor_readings_time[0])
+                cur_hyd_scada_data = self._hydraulic_scada_data.\
+                    extract_time_window(cur_time, cur_time)
+                scada_data.join(cur_hyd_scada_data)
 
             if self.autoreset is True:
-                return r
+                return scada_data
             else:
-                return r, False
+                return scada_data, False
         except StopIteration:
             if self.__autoreset is True:
                 return self.reset()
@@ -112,6 +165,10 @@ class ScenarioControlEnv(ABC):
                 - EN_CLOSED  = 0
                 - EN_OPEN    = 1
         """
+        if self._scenario_sim.f_msx_in is not None:
+            raise RuntimeError("Can not execute actions affecting the hydraulics "+
+                               "when running EPANET-MSX")
+
         pump_idx = self._scenario_sim.epanet_api.getLinkPumpNameID().index(pump_id)
         pump_link_idx = self._scenario_sim.epanet_api.getLinkPumpIndex(pump_idx + 1)
         self._scenario_sim.epanet_api.setLinkStatus(pump_link_idx, status)
@@ -127,6 +184,10 @@ class ScenarioControlEnv(ABC):
         speed : `float`
             New pump speed.
         """
+        if self._scenario_sim.f_msx_in is not None:
+            raise RuntimeError("Can not execute actions affecting the hydraulics "+
+                               "when running EPANET-MSX")
+
         pump_idx = self._scenario_sim.epanet_api.getLinkPumpNameID().index(pump_id)
         pattern_idx = self._scenario_sim.epanet_api.getLinkPumpPatternIndex(pump_idx + 1)
 
@@ -154,6 +215,10 @@ class ScenarioControlEnv(ABC):
                 - EN_CLOSED  = 0
                 - EN_OPEN    = 1
         """
+        if self._scenario_sim.f_msx_in is not None:
+            raise RuntimeError("Can not execute actions affecting the hydraulics "+
+                               "when running EPANET-MSX")
+
         valve_idx = self._scenario_sim.epanet_api.getLinkValveNameID().index(valve_id)
         valve_link_idx = self._scenario_sim.epanet_api.getLinkValveIndex()[valve_idx]
         self._scenario_sim.epanet_api.setLinkStatus(valve_link_idx, status)
@@ -173,11 +238,65 @@ class ScenarioControlEnv(ABC):
         qual_value : `float`
             New quality source value.
         """
+        if self._scenario_sim.f_msx_in is not None:
+            raise RuntimeError("Can not execute actions affecting the hydraulics "+
+                               "when running EPANET-MSX")
+
         node_idx = self._scenario_sim.epanet_api.getNodeIndex(node_id)
         pattern_idx = self._scenario_sim.epanet_api.getPatternIndex(pattern_id)
         self._scenario_sim.epanet_api.setNodeSourceQuality(node_idx, 1)
         self._scenario_sim.epanet_api.setPattern(pattern_idx, np.array([qual_value]))
 
+    def set_node_species_source_value(self, species_id: str, node_id: str, source_type: int,
+                                      pattern_id: str, source_strength: float) -> None:
+        """
+        Sets the species source at a particular node to a specific value -- i.e.
+        setting the species injection amount at a particular location.
+
+        Parameters
+        ----------
+        species_id : `str`
+            ID of the species.
+        node_id : `str`
+            ID of the node.
+        source_type : `int`
+            Type of the external species injection source -- must be one of
+            the following EPANET toolkit constants:
+
+                - EN_CONCEN     = 0
+                - EN_MASS       = 1
+                - EN_SETPOINT   = 2
+                - EN_FLOWPACED  = 3
+
+            Description:
+
+                - E_CONCEN Sets the concentration of external inflow entering a node
+                - EN_MASS Injects a given mass/minute into a node
+                - EN_SETPOINT Sets the concentration leaving a node to a given value
+                - EN_FLOWPACED Adds a given value to the concentration leaving a node
+        pattern_id : `str`
+            ID of the source pattern.
+        source_strength : `float`
+            Amount of the injected species (source strength) --
+            i.e. interpreation of this number depends on `source_type`
+        """
+        if self._scenario_sim.f_msx_in is None:
+            raise RuntimeError("You are not running EPANET-MSX")
+
+        source_type_ = "None"
+        if source_type == ToolkitConstants.EN_CONCEN:
+            source_type_ = "CONCEN"
+        elif source_type == ToolkitConstants.EN_MASS:
+            source_type_ = "MASS"
+        elif source_type == ToolkitConstants.EN_SETPOINT:
+            source_type_ = "SETPOINT"
+        elif source_type == ToolkitConstants.EN_FLOWPACED:
+            source_type_ = "FLOWPACED"
+
+        self._scenario_sim.epanet_api.setMSXPattern(pattern_id, [1])
+        self._scenario_sim.epanet_api.setMSXSources(node_id, species_id, source_type_,
+                                                    source_strength, pattern_id)
+
     @abstractmethod
     def step(self, *actions) -> Union[tuple[ScadaData, float, bool], tuple[ScadaData, float]]:
         """

epyt_flow/serialization.py

@@ -47,6 +47,7 @@ NETWORK_TOPOLOGY_ID                     = 26
 PUMP_STATE_EVENT_ID                     = 28
 PUMP_SPEED_EVENT_ID                     = 29
 VALVE_STATE_EVENT_ID                    = 30
+SPECIESINJECTION_EVENT_ID               = 31
 
 
 def my_packb(data: Any) -> bytes:
@@ -452,9 +453,15 @@ def save_to_file(f_out: str, data: Any, use_compression: bool = True) -> None:
 def __encode_bsr_array(array: scipy.sparse.bsr_array
                        ) -> tuple[tuple[int, int], tuple[list[float], tuple[list[int], list[int]]]]:
     shape = array.shape
-    data = array.data.flatten().tolist()
-    rows = array.nonzero()[0].tolist()
-    cols = array.nonzero()[1].tolist()
+    data = []
+    rows = []
+    cols = []
+
+    array_ = array.tocsr()   # Bug workaround: BSR arrays do not implement __getitem__
+    for i, j in zip(*array_.nonzero()):
+        rows.append(int(i))
+        cols.append(int(j))
+        data.append(float(array_[i, j]))
 
     return shape, (data, (rows, cols))
 

epyt_flow/simulation/events/__init__.py

@@ -1,5 +1,6 @@
 from .system_event import *
 from .leakages import *
+from .quality_events import *
 from .sensor_reading_event import *
 from .sensor_faults import *
 from .sensor_reading_attack import *

epyt_flow/simulation/events/leakages.py

@@ -60,8 +60,8 @@ class Leakage(SystemEvent, JsonSerializable):
         if area is None and diameter is None:
             raise ValueError("Either 'diameter' or 'area' must be given")
         if area is not None and diameter is not None:
-                raise ValueError("Either 'diameter' or 'area' must be given, " +
-                                 "but not both at the same time")
+            raise ValueError("Either 'diameter' or 'area' must be given, " +
+                             "but not both at the same time")
         if diameter is not None:
             if not isinstance(diameter, float):
                 raise TypeError("'diameter must be an instance of 'float' but " +
@@ -92,7 +92,7 @@ class Leakage(SystemEvent, JsonSerializable):
         self.__area = area
         self.__profile = profile
 
-        self.__leaky_node_id = None
+        self.__leaky_node_idx = None
         self.__leak_emitter_coef = None
         self.__time_pattern_idx = 0
 
@@ -174,7 +174,7 @@ class Leakage(SystemEvent, JsonSerializable):
     def get_attributes(self) -> dict:
         return super().get_attributes() | {"link_id": self.__link_id, "diameter": self.__diameter,
                                            "area": self.__area, "profile": self.__profile,
-                                           "node_id": self.__leaky_node_id
+                                           "node_id": self.__node_id
                                            if self.__link_id is None else None}
 
     def __eq__(self, other) -> bool:
@@ -238,10 +238,16 @@ class Leakage(SystemEvent, JsonSerializable):
             g = 32.17405    # feet/s^2
         else:
             raise ValueError("Leakages are only implemented for the following flow units:\n" +
-                             " EN_CMH (cubic foot/sec)\n EN_CFS (cubic meter/hr)")
+                             " EN_CMH (cubic meter/hr)\n EN_CFS (foot/sec)")
 
         return discharge_coef * area * np.sqrt(2. * g)
 
+    def _get_new_link_id(self) -> str:
+        return f"leak_pipe_{self.__link_id}"
+
+    def _get_new_node_id(self) -> str:
+        return f"leak_node_{self.__link_id}"
+
     def init(self, epanet_api: epyt.epanet) -> None:
         super().init(epanet_api)
 
@@ -250,35 +256,72 @@ class Leakage(SystemEvent, JsonSerializable):
             if self.__link_id not in self._epanet_api.getLinkNameID():
                 raise ValueError(f"Unknown link/pipe '{self.__link_id}'")
 
-            new_link_id = f"leak_pipe_{self.link_id}"
-            new_node_id = f"leak_node_{self.link_id}"
+            new_link_id = self._get_new_link_id()
+            new_node_id = self._get_new_node_id()
 
             all_nodes_id = self._epanet_api.getNodeNameID()
             if new_node_id in all_nodes_id:
                 raise ValueError(f"There is already a leak at pipe {self.link_id}")
 
             self._epanet_api.splitPipe(self.link_id, new_link_id, new_node_id)
-            self.__leaky_node_id = self._epanet_api.getNodeIndex(new_node_id)
+            self.__leaky_node_idx = self._epanet_api.getNodeIndex(new_node_id)
         else:
             if self.__node_id not in self._epanet_api.getNodeNameID():
                 raise ValueError(f"Unknown node '{self.__node_id}'")
 
-            self.__leaky_node_id = self._epanet_api.getNodeIndex(self.__node_id)
+            self.__leaky_node_idx = self._epanet_api.getNodeIndex(self.__node_id)
 
-        self._epanet_api.setNodeEmitterCoeff(self.__leaky_node_id, 0.)
+        self._epanet_api.setNodeEmitterCoeff(self.__leaky_node_idx, 0.)
 
         # Compute leak emitter coefficient
         self.__leak_emitter_coef = self.compute_leak_emitter_coefficient(
             self.compute_leak_area(self.area))
 
+    def cleanup(self) -> None:
+        if self.__link_id is not None:
+            pipe_idx = self._epanet_api.getLinkIndex(self.__link_id)
+            link_prop = self._epanet_api.getLinksInfo()
+            link_diameter = link_prop.LinkDiameter[pipe_idx - 1]
+            link_length = link_prop.LinkLength[pipe_idx - 1] * 2.
+            link_roughness_coeff = link_prop.LinkRoughnessCoeff[pipe_idx - 1]
+            link_minor_loss_coeff = link_prop.LinkMinorLossCoeff[pipe_idx - 1]
+            link_initial_status = link_prop.LinkInitialStatus[pipe_idx - 1]
+            link_initial_setting = link_prop.LinkInitialSetting[pipe_idx - 1]
+            link_bulk_reaction_coeff = link_prop.LinkBulkReactionCoeff[pipe_idx - 1]
+            link_wall_reaction_coeff = link_prop.LinkWallReactionCoeff[pipe_idx - 1]
+
+            node_a_idx = int(self._epanet_api.getLinkNodesIndex(pipe_idx)[0])
+            node_b_idx = int(self._epanet_api.getLinkNodesIndex(self._get_new_link_id())[1])
+
+            self._epanet_api.deleteLink(self._get_new_link_id())
+            self._epanet_api.deleteLink(self.__link_id)
+            self._epanet_api.deleteNode(self._get_new_node_id())
+
+            self._epanet_api.addLinkPipe(self.__link_id,
+                                         self._epanet_api.getNodeNameID(node_a_idx),
+                                         self._epanet_api.getNodeNameID(node_b_idx))
+            link_idx = self._epanet_api.getLinkIndex(self.__link_id)
+            self._epanet_api.setLinkNodesIndex(link_idx,
+                                               node_a_idx, node_b_idx)
+            self._epanet_api.setLinkPipeData(link_idx, link_length, link_diameter,
+                                             link_roughness_coeff,
+                                             link_minor_loss_coeff)
+            if link_minor_loss_coeff != 0:
+                self._epanet_api.setLinklinkMinorLossCoeff(link_idx, link_minor_loss_coeff)
+            self._epanet_api.setLinkInitialStatus(link_idx, link_initial_status)
+            self._epanet_api.setLinkInitialSetting(link_idx, link_initial_setting)
+            self._epanet_api.setLinkBulkReactionCoeff(link_idx, link_bulk_reaction_coeff)
+            self._epanet_api.setLinkWallReactionCoeff(link_idx, link_wall_reaction_coeff)
+            self._epanet_api.setLinkTypePipe(link_idx)
+
     def reset(self) -> None:
         self.__time_pattern_idx = 0
 
     def exit(self, cur_time) -> None:
-        self._epanet_api.setNodeEmitterCoeff(self.__leaky_node_id, 0.)
+        self._epanet_api.setNodeEmitterCoeff(self.__leaky_node_idx, 0.)
 
     def apply(self, cur_time: int) -> None:
-        self._epanet_api.setNodeEmitterCoeff(self.__leaky_node_id,
+        self._epanet_api.setNodeEmitterCoeff(self.__leaky_node_idx,
                                              self.__leak_emitter_coef *
                                              self.__profile[self.__time_pattern_idx])
         self.__time_pattern_idx += 1

epyt_flow/simulation/events/quality_events.py

@@ -0,0 +1,194 @@
+"""
+Module provides a class for implementing species injection (e.g. contamination) events.
+"""
+from copy import deepcopy
+import warnings
+import math
+import numpy as np
+import epyt
+from epyt.epanet import ToolkitConstants
+
+from .system_event import SystemEvent
+from ...serialization import serializable, JsonSerializable, \
+    SPECIESINJECTION_EVENT_ID
+
+
+@serializable(SPECIESINJECTION_EVENT_ID, ".epytflow_speciesinjection_event")
+class SpeciesInjectionEvent(SystemEvent, JsonSerializable):
+    """
+    Class implementing a (bulk) species injection event -- e.g. modeling a contamination event.
+
+    Parameters
+    ----------
+    species_id : `str`
+        ID of the bulk species that is going to be injected.
+    node_id : `str`
+        ID of the node at which the injection is palced.
+    profile : `numpy.ndarray`
+        Injection strength profile -- i.e. every entry corresponds to the strength of the injection
+        at a point in time. Pattern will repeat if it is shorter than the total injection time.
+    source_type : `int`
+        Type of the bulk species injection source -- must be one of
+        the following EPANET toolkit constants:
+
+            - EN_CONCEN     = 0
+            - EN_MASS       = 1
+            - EN_SETPOINT   = 2
+            - EN_FLOWPACED  = 3
+
+        Description:
+
+            - E_CONCEN Sets the concentration of external inflow entering a node
+            - EN_MASS Injects a given mass/minute into a node
+            - EN_SETPOINT Sets the concentration leaving a node to a given value
+            - EN_FLOWPACED Adds a given value to the concentration leaving a node
+    """
+    def __init__(self, species_id: str, node_id: str, profile: np.ndarray, source_type: int,
+                 **kwds):
+        if not isinstance(species_id, str):
+            raise TypeError("'species_id' must be an instance of 'str' but not of " +
+                            f"'{type(species_id)}'")
+        if not isinstance(node_id, str):
+            raise TypeError("'node_id' must be an instance of 'str' but not of " +
+                            f"'{type(node_id)}'")
+        if not isinstance(profile, np.ndarray):
+            raise TypeError("'profile' must be an instance of 'numpy.ndarray' but not of " +
+                            f"'{type(profile)}'")
+        if not isinstance(source_type, int):
+            raise TypeError("'source_type' must be an instance of 'int' but not of " +
+                            f"'{type(source_type)}'")
+        if not 0 <= source_type <= 3:
+            raise ValueError("'source_tye' must be in [0, 3]")
+
+        self.__species_id = species_id
+        self.__node_id = node_id
+        self.__profile = profile
+        self.__source_type = source_type
+
+        super().__init__(**kwds)
+
+    @property
+    def species_id(self) -> str:
+        """
+        Gets the ID of the bulk species that is going to be injected.
+
+        Returns
+        -------
+        `str`
+            Bulk species ID.
+        """
+        return self.__species_id
+
+    @property
+    def node_id(self) -> str:
+        """
+        Gets the ID of the node at which the injection is palced.
+
+        Returns
+        -------
+        `str`
+            Node ID.
+        """
+        return self.__node_id
+
+    @property
+    def profile(self) -> np.ndarray:
+        """
+        Gets the injection strength profile.
+
+        Returns
+        -------
+        `numpy.ndarray`
+            Pattern of the injection.
+        """
+        return deepcopy(self.__profile)
+
+    @property
+    def source_type(self) -> int:
+        """
+        Type of the bulk species injection source -- will be one of
+        the following EPANET toolkit constants:
+
+            - EN_CONCEN     = 0
+            - EN_MASS       = 1
+            - EN_SETPOINT   = 2
+            - EN_FLOWPACED  = 3
+
+        Returns
+        -------
+        `int`
+            Type of the injection source.
+        """
+        return self.__source_type
+
+    def get_attributes(self) -> dict:
+        return super().get_attributes() | {"species_id": self.__species_id,
+                                           "node_id": self.__node_id, "profile": self.__profile,
+                                           "source_type": self.__source_type}
+
+    def __eq__(self, other) -> bool:
+        return super().__eq__(other) and self.__species_id == other.species_id and \
+            self.__node_id == other.node_id and np.all(self.__profile == other.profile) and \
+            self.__source_type == other.source_type
+
+    def __str__(self) -> str:
+        return f"{super().__str__()} species_id: {self.__species_id} " +\
+            f"node_id: {self.__node_id} profile: {self.__profile} source_type: {self.__source_type}"
+
+    def _get_pattern_id(self) -> str:
+        return f"{self.__species_id}_{self.__node_id}_{self.start_time}"
+
+    def init(self, epanet_api: epyt.epanet) -> None:
+        super().init(epanet_api)
+
+        # Check parameters
+        if self.__species_id not in self._epanet_api.getMSXSpeciesNameID():
+            raise ValueError(f"Unknown species '{self.__species_id}'")
+        if self.__node_id not in self._epanet_api.getNodeNameID():
+            raise ValueError(f"Unknown node '{self.__node_id}'")
+
+        # Create final injection strength pattern
+        total_sim_duration = self._epanet_api.getTimeSimulationDuration()
+        time_step = self._epanet_api.getTimeHydraulicStep()
+
+        pattern = np.zeros(math.ceil(total_sim_duration / time_step))
+
+        end_time = self.end_time if self.end_time is not None else total_sim_duration
+        injection_pattern_length = math.ceil((end_time - self.start_time) / time_step)
+        injection_time_start_idx = int(self.start_time / time_step)
+
+        injection_pattern = None
+        if len(self.__profile) == injection_pattern_length:
+            injection_pattern = self.profile
+        else:
+            injection_pattern = np.tile(self.profile,
+                                        math.ceil(injection_pattern_length / len(self.profile)))
+
+        pattern[injection_time_start_idx:
+                injection_time_start_idx + injection_pattern_length] = injection_pattern
+
+        # Create injection
+        source_type_ = "None"
+        if self.__source_type == ToolkitConstants.EN_CONCEN:
+            source_type_ = "CONCEN"
+        elif self.__source_type == ToolkitConstants.EN_MASS:
+            source_type_ = "MASS"
+        elif self.__source_type == ToolkitConstants.EN_SETPOINT:
+            source_type_ = "SETPOINT"
+        elif self.__source_type == ToolkitConstants.EN_FLOWPACED:
+            source_type_ = "FLOWPACED"
+
+        pattern_id = self._get_pattern_id()
+        if pattern_id in self._epanet_api.getMSXPatternsNameID():
+            raise ValueError("Duplicated injection event")
+
+        self._epanet_api.addMSXPattern(pattern_id, pattern)
+        self._epanet_api.setMSXSources(self.__node_id, self.__species_id, source_type_, 1,
+                                       pattern_id)
+
+    def cleanup(self) -> None:
+        warnings.warn("Can not undo SpeciedInjectionEvent -- " +
+                      "EPANET-MSX does not support removing patterns")
+
+    def apply(self, cur_time: int) -> None:
+        pass

epyt_flow/simulation/events/system_event.py

@@ -73,6 +73,11 @@ class SystemEvent(Event):
             Current time (seconds since the start) in the simulation.
         """
 
+    def cleanup(self) -> None:
+        """
+        Clean up any changes/modifications made by this event.
+        """
+
     @abstractmethod
     def apply(self, cur_time: int) -> None:
         """