opentnsim 2.2.2__py3-none-any.whl

opentnsim/__init__.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+from importlib.metadata import version, PackageNotFoundError
+
+import opentnsim.core as core  # now contains mixin class consumes energy, also the modified vessel properties
+import opentnsim.energy as energy
+import opentnsim.graph.mixins as mixins
+import opentnsim.lock as lock
+import opentnsim.model as model
+import opentnsim.plot as plot
+import opentnsim.strategy as strategy
+
+
+"""Top-level package for OpenTNSim."""
+
+__author__ = """Mark van Koningsveld"""
+__email__ = "M.vanKoningsveld@tudelft.nl"
+
+try:
+    __version__ = version("opentnsim")
+except PackageNotFoundError:
+    # Package is not installed yet (e.g., running tests from source without an install)
+    # This value will be replaced by the build system when the package is installed
+    __version__ = "uninstalled" 

opentnsim/cli.py

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+
+"""Console script for opentnsim."""
+# package(s) related to the command line interface
+import sys
+
+import click
+
+import opentnsim.server
+
+
+@click.group()
+def cli(args=None):
+    """OpenTNSim simulation."""
+    click.echo("Replace this message by putting your code into " "opentnsim.cli.main")
+    click.echo("See click documentation at http://click.pocoo.org/")
+    return 0
+
+
+@cli.command()
+@click.option("--host", default="0.0.0.0")
+@click.option("--port", default=5000, type=int)
+@click.option("--debug/--no-debug", default=False)
+def serve(host, port, debug, args=None):
+    """Run a flask server with the backend code"""
+    app = opentnsim.server.app
+    app.run(host=host, debug=debug, port=port)
+
+
+if __name__ == "__main__":
+    sys.exit(cli())  # pragma: no cover

opentnsim/constants.py

@@ -0,0 +1,5 @@
+"""This module contains constants used in the simulation."""
+
+# Constants
+knots_to_ms = knots = 0.514444444
+gravitational_acceleration = 9.81

opentnsim/core/__init__.py

@@ -0,0 +1,28 @@
+from openclsim.core import Identifiable, Locatable, Log, SimpyObject
+
+from .container import HasContainer
+from .misc import ExtraMetadata, Neighbours
+from .movable import ContainerDependentMovable, Movable, Routable, Routeable
+from .resource import HasResource
+from .vessel_properties import HasLength, HasLoad, VesselProperties
+from . import logutils, plotutils
+
+__all__ = [
+    "Identifiable",
+    "Locatable",
+    "Log",
+    "SimpyObject",
+    "HasContainer",
+    "ExtraMetadata",
+    "Neighbours",
+    "ContainerDependentMovable",
+    "Movable",
+    "Routable",
+    "Routeable",
+    "HasResource",
+    "HasLength",
+    "HasLoad",
+    "VesselProperties",
+    "logutils",
+    "plotutils",
+]

opentnsim/core/container.py

@@ -0,0 +1,63 @@
+"""
+Mixin classes related to containers.
+
+The following classes are provided:
+- HasContainer
+
+"""
+# package(s) for documentation, debugging, saving and loading
+import logging
+
+# package(s) related to the simulation
+import simpy
+
+# use OpenCLSim objects for core objects (identifiable is imported for later use)
+from openclsim.core import SimpyObject
+
+# get logger
+logger = logging.getLogger(__name__)
+
+
+class HasContainer(SimpyObject):
+    """Mixin class: Something with a container, modelled as a storage capacity
+
+    Parameters
+    -----------
+    capacity: float
+        the capacity of the container, which may either be continuous (like water) or discrete (like apples)
+    level: int, default=0
+        level of the container at the beginning of the simulation
+    total_requested: int, default=0
+        total amount that has been requested at the beginning of the simulation
+    args, kwargs:
+        passed to SimpyObject. Must at least contain parameter env: simpy.Environment.
+
+    Attributes
+    -----------
+    container: simpy.Container
+        the container that is used to limit the amount that can be requested.
+    total_requested: int
+        total amount that has been requested.
+    """
+
+    def __init__(self, capacity: float, level: float = 0, total_requested: float = 0, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        """Initialization"""
+        self.container = simpy.Container(self.env, capacity, init=level)
+        self.total_requested = total_requested
+
+    @property
+    def is_loaded(self):
+        """Return if the container is loaded"""
+        return True if self.container.level > 0 else False
+
+    @property
+    def filling_degree(self):
+        """return the filling degree of the container"""
+        return self.container.level / self.container.capacity
+
+    @property
+    def max_load(self):
+        """return the maximum cargo to load"""
+        # independent of trip
+        return self.container.capacity - self.container.level

opentnsim/core/logutils.py

@@ -0,0 +1,182 @@
+"""
+Core utiltities related to logging.
+"""
+
+# %% IMPORT DEPENDENCIES
+# generic
+import pandas as pd
+
+from shapely import Point
+
+# internal
+import opentnsim.graph.mixins as mixins
+
+
+# # %% CONVERT LOG TO EVENT TABLE
+# def logbook2eventtable(objs):
+#     """
+#     Transform object logbooks into a 'minimum event table'.
+
+#     Implements the basic 'event table' concept as proposed by Van der Werff:
+
+#     Van der Werff, S.E., F. Baart and M. van Koningsveld (2025). “Merging Multiple
+#     System Perspectives: The Key to Effective Inland Shipping Emission-Reduction
+#     Policy Design.” Journal of Marine Science and engineering 13(4), 716.
+#     https://doi.org/10.3390/jmse13040716
+
+#     Van der Werff, S.E., S. Eppenga, A. van der Hout, F. Baart and M. van
+#     Koningsveld (2025). “Multi-perspective nautical safety risk assessment of
+#     allisions with offshore wind parks.” Applied Ocean Research 158(2025),104564.
+#     https://doi.org/10.1016/j.apor.2025.104564
+
+#     For waterborne traffic over a network, a unique event is defined by:
+#      - a unique vessel,
+#      - a specific section of the waterway,
+#      - a specific time.
+
+#     Parameters
+#     ----------
+#     objs: list
+#         List of OpenTNSim simulation objects with log information.
+
+#     Returns
+#     -------
+#     eventtable: pandas.DataFrame
+#         DataFrame with all events from obj.logbook attributes in objs.
+#     """
+#     # check if all objects have a logbook with expected structure
+#     for obj in objs:
+#         if (
+#             not hasattr(obj, "logbook")
+#             or not hasattr(obj, "id")
+#             or not hasattr(obj, "name")
+#         ):
+#             raise ValueError(
+#                 f"Object {obj} does not have a logbook or id/name attributes."
+#             )
+
+#     # construct all logged events
+#     events = []
+#     for obj in objs:
+#         df = pd.DataFrame.from_dict(obj.logbook)
+
+#         unique_activities = df["Message"].str.replace(" start", "").str.replace(" stop", "").unique()
+#         for activity in unique_activities:
+#             start_time = df[df.Message == activity + " start"]["Timestamp"].values[0]
+#             stop_time = df[df.Message == activity + " stop"]["Timestamp"].values[0]
+
+#             start_location = df[df.Message == activity + " start"]["Geometry"].values[0]
+#             stop_location = df[df.Message == activity + " stop"]["Geometry"].values[0]
+
+#             duration_seconds = (stop_time - start_time) / pd.Timedelta(seconds=1)
+
+#             if isinstance(start_location, Point):
+#                 distance_meters = opentnsim.graph.calculate_distance(start_location, stop_location)
+#             else:
+#                 distance_meters = None
+
+#             events.append(
+#                 {
+#                     "object id": obj.id,
+#                     "object name": obj.name,
+#                     "activity name": activity,
+#                     "start location": start_location,
+#                     "stop location": stop_location,
+#                     "start time": start_time,
+#                     "stop time": stop_time,
+#                     "distance (m)": distance_meters,
+#                     "duration (s)": duration_seconds,
+#                 }
+#             )
+
+#     # Final DataFrame
+#     eventtable = pd.DataFrame(events)
+
+#     return eventtable
+
+def logbook2eventtable(objs):
+    """
+    Transform object logbooks into a 'minimum event table'.
+
+    Implements the basic 'event table' concept as proposed by Van der Werff:
+
+    Van der Werff, S.E., F. Baart and M. van Koningsveld (2025). “Merging Multiple
+    System Perspectives: The Key to Effective Inland Shipping Emission-Reduction
+    Policy Design.” Journal of Marine Science and engineering 13(4), 716.
+    https://doi.org/10.3390/jmse13040716
+
+    Van der Werff, S.E., S. Eppenga, A. van der Hout, F. Baart and M. van
+    Koningsveld (2025). “Multi-perspective nautical safety risk assessment of
+    allisions with offshore wind parks.” Applied Ocean Research 158(2025),104564.
+    https://doi.org/10.1016/j.apor.2025.104564
+
+    For waterborne traffic over a network, a unique event is defined by:
+     - a unique vessel,
+     - a specific section of the waterway,
+     - a specific time.
+
+    Parameters
+    ----------
+    objs: list
+        List of OpenTNSim simulation objects with log information.
+
+    Returns
+    -------
+    eventtable: pandas.DataFrame
+        DataFrame with all events from obj.logbook attributes in objs.
+    """
+    # check if all objects have a logbook with expected structure
+    for obj in objs:
+        if (
+            not hasattr(obj, "logbook")
+            or not hasattr(obj, "id")
+            or not hasattr(obj, "name")
+        ):
+            raise ValueError(
+                f"Object {obj} does not have a logbook or id/name attributes."
+            )
+
+    # construct all logged events
+    events = []
+    for obj in objs:
+        df = pd.DataFrame.from_dict(obj.logbook)
+        df.sort_values(by="Timestamp", inplace=True)
+
+        for i in range(0, len(df)):
+            start_row = df.iloc[i]
+            if start_row["Message"].endswith(" start"):
+                activity = start_row["Message"].replace(" start", "")
+            else:
+                continue  # skip non-start messages
+
+            stop_row = df[(df["Message"] == activity + " stop") & (df["Timestamp"] > df.iloc[i]["Timestamp"])].iloc[0]
+
+            start_time = start_row["Timestamp"]
+            stop_time = stop_row["Timestamp"]
+            start_location = start_row["Geometry"]
+            stop_location = stop_row["Geometry"]
+
+            duration_seconds = (stop_time - start_time).total_seconds()
+            if isinstance(start_location, Point):
+                distance_meters = mixins.calculate_distance(start_location, stop_location)
+            else:
+                distance_meters = None
+
+            events.append(
+                {
+                    "object id": obj.id,
+                    "object name": obj.name,
+                    "activity name": activity,
+                    "start location": start_location,
+                    "stop location": stop_location,
+                    "start time": start_time,
+                    "stop time": stop_time,
+                    "distance (m)": distance_meters,
+                    "duration (s)": duration_seconds,
+                }
+            )
+
+    # Final DataFrame
+    eventtable = pd.DataFrame(events)
+
+    return eventtable

opentnsim/core/misc.py

@@ -0,0 +1,48 @@
+"""
+Miscellaneous mixin classes for object in OpenTNSim.
+
+The following classes are provided:
+- Neighbours
+- ExtraMetadata
+
+"""
+# package(s) for documentation, debugging, saving and loading
+import logging
+from typing import Union
+
+# math packages
+import numpy as np
+
+# get logger
+logger = logging.getLogger(__name__)
+
+
+class Neighbours:
+    """Mixin class: Can be added to a locatable object (list)
+
+    Parameters
+    ----------
+    travel_to: list
+            list of locatables to which can be travelled
+    args, kwargs:
+        passed to SimpyObject. Must at least contain parameter env: simpy.Environment.
+
+    Attributes
+    -----------
+    neighbours: list
+        list of locatables to which can be travelled.
+    """
+
+    def ___init(self, travel_to: list, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        """Initialization"""
+        self.neighbours = travel_to
+
+
+class ExtraMetadata:
+    """Mixin class: store all leftover keyword arguments as metadata property (use as last mixin)"""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args)
+        # store all other properties as metadata
+        self.metadata = kwargs