eflips-depot 4.9.1__tar.gz → 4.11.0__tar.gz

{eflips_depot-4.9.1 → eflips_depot-4.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: eflips-depot
-Version: 4.9.1
+Version: 4.11.0
 Summary: Depot Simulation for eFLIPS
 License: AGPL-3.0-or-later
 Author: Enrico Lauth

{eflips_depot-4.9.1 → eflips_depot-4.11.0}/eflips/depot/api/__init__.py

@@ -49,6 +49,9 @@ from eflips.model import (
     AreaType,
     ChargeType,
     Route,
+    ConsistencyWarning,
+    Station,
+    ConsumptionLut,
 )
 from sqlalchemy.orm import Session
 
@@ -57,16 +60,19 @@ from eflips.depot import (
     DepotEvaluation,
     SimulationHost,
 )
+from eflips.depot.api.private.consumption import ConsumptionResult
 from eflips.depot.api.private.consumption import (
     initialize_vehicle,
     add_initial_standby_event,
     attempt_opportunity_charging_event,
+    extract_trip_information,
 )
 from eflips.depot.api.private.depot import (
     delete_depots,
     depot_to_template,
     group_rotations_by_start_end_stop,
     generate_depot,
+    depot_smallest_possible_size,
 )
 from eflips.depot.api.private.results_to_database import (
     get_finished_schedules_per_vehicle,
@@ -113,37 +119,33 @@ class SmartChargingStrategy(Enum):
     """
 
 
-@dataclass
-class ConsumptionResult:
+def generate_consumption_result(scenario):
     """
-    A dataclass that stores the results of a charging simulation for a single trip.
-
-    This class holds both the total change in battery State of Charge (SoC) over the trip
-    as well as an optional timeseries of timestamps and incremental SoC changes. When
-    an entry exists for a given trip in ``consumption_result``, the simulation will use
-    these precomputed values instead of recalculating the SoC changes from the vehicle
-    distance and consumption.
-
-    :param delta_soc_total:
-        The total change in the vehicle's State of Charge over the trip, typically
-        negative if the vehicle is consuming energy (e.g., -0.15 means the SoC
-        dropped by 15%).
-
-    :param timestamps:
-        A list of timestamps (e.g., arrival times at stops) that mark the times
-        associated with the SoC changes. The number of timestamps must match the
-        number of entries in ``delta_soc``.
-
-    :param delta_soc:
-        A list of cumulative SoC changes corresponding to the ``timestamps``.
-        For example, if ``delta_soc[i] = -0.02``, it means the SoC decreased by 2%
-        between from the start of the trip to ``timestamps[i]``. This list should typically
-        be a monotonic decreasing sequence.
+    Generate consumption information for the scenario.
+
+    This function retrieves the consumption LUT and vehicle classes from the database and returns a dictionary
+    containing the consumption information for each vehicle type in the scenario.
+
+    :param scenario: A :class:`eflips.model.Scenario` object containing the input data for the simulation.
+
+    :return: A dictionary containing the consumption information for each vehicle type in the scenario.
     """
 
-    delta_soc_total: float
-    timestamps: List[datetime] | None
-    delta_soc: List[float] | None
+    with create_session(scenario) as (session, scenario):
+        trips = session.query(Trip).filter(Trip.scenario_id == scenario.id).all()
+        consumption_results = {}
+        for trip in trips:
+            consumption_info = extract_trip_information(
+                trip.id,
+                scenario,
+            )
+            battery_capacity_current_vt = trip.rotation.vehicle_type.battery_capacity
+            consumption_result = consumption_info.generate_consumption_result(
+                battery_capacity_current_vt
+            )
+            consumption_results[trip.id] = consumption_result
+
+    return consumption_results
 
 
 def simple_consumption_simulation(
@@ -492,19 +494,14 @@ def generate_depot_layout(
 
             # Create one direct slot for each rotation (it's way too much, but should work)
             vt_capacity_dict: Dict[VehicleType, Dict[AreaType, None | int]] = {}
+            rotation_count_depot = 0
             for vehicle_type, rotations in vehicle_type_dict.items():
-                rotation_count = len(rotations)
                 vt_capacity_dict[vehicle_type] = {
                     AreaType.LINE: None,
-                    AreaType.DIRECT_ONESIDE: rotation_count,
+                    AreaType.DIRECT_ONESIDE: len(rotations),
                     AreaType.DIRECT_TWOSIDE: None,
                 }
-
-            total_rotation_count = (
-                session.query(Rotation)
-                .filter(Rotation.scenario_id == scenario.id)
-                .count()
-            )
+                rotation_count_depot += len(rotations)
 
             generate_depot(
                 vt_capacity_dict,
@@ -512,8 +509,8 @@ def generate_depot_layout(
                 scenario,
                 session,
                 charging_power=charging_power,
-                num_shunting_slots=max(total_rotation_count // 10, 1),
-                num_cleaning_slots=max(total_rotation_count // 10, 1),
+                num_shunting_slots=max(rotation_count_depot // 10, 1),
+                num_cleaning_slots=max(rotation_count_depot // 10, 1),
             )
 
 
@@ -1097,3 +1094,138 @@ def add_evaluation_to_database(
         # Postprocessing of events
         update_vehicle_in_rotation(session, scenario, list_of_assigned_schedules)
         update_waiting_events(session, scenario, waiting_area_id)
+
+
+def generate_depot_optimal_size(
+    scenario: Scenario,
+    standard_block_length: int = 6,
+    charging_power: float = 90,
+    database_url: Optional[str] = None,
+    delete_existing_depot: bool = False,
+    consumption_results: Optional[Dict[int, ConsumptionResult]] = None,
+) -> None:
+    """
+    Generates an optimal depot layout with the smallest possible size for each depot in the scenario. Line charging areas
+     with given block length area preferred. The existing depot will be deleted if `delete_existing_depot` is set to True.
+
+    :param scenario: A :class:`eflips.model.Scenario` object containing the input data for the simulation.
+    :param standard_block_length: The standard block length for the depot layout in meters. Default is 6.
+    :param charging_power: The charging power of the charging area in kW. Default is 90.
+    :param database_url: An optional database URL. Used if no database url is given by the environment variable.
+    :param delete_existing_depot: If there is already a depot existing in this scenario, set True to delete this
+        existing depot. Set to False and a ValueError will be raised if there is a depot in this scenario.
+    :param consumption_results: A dictionary of consumption results for each vehicle type. It is used to simulate the consumption with
+        given look-up tables. If not given, the constant consumption will be used in the simulation.
+
+    :return: None. The depot layout will be added to the database.
+
+    """
+
+    logger = logging.getLogger(__name__)
+
+    with create_session(scenario, database_url) as (session, scenario):
+        # Delete all vehicles and events, also disconnect the vehicles from the rotations
+        rotation_q = session.query(Rotation).filter(Rotation.scenario_id == scenario.id)
+        rotation_q.update({"vehicle_id": None})
+        session.query(Event).filter(Event.scenario_id == scenario.id).delete()
+        session.query(Vehicle).filter(Vehicle.scenario_id == scenario.id).delete()
+
+        # Handles existing depot
+        if session.query(Depot).filter(Depot.scenario_id == scenario.id).count() != 0:
+            if delete_existing_depot is False:
+                raise ValueError("Depot already exists.")
+
+            delete_depots(scenario, session)
+
+        ##### Step 0: Consumption Simulation #####
+        # Run the consumption simulation for all depots
+        simple_consumption_simulation(
+            scenario, initialize_vehicles=True, consumption_result=consumption_results
+        )
+
+        ##### Step 1: Find all potential depots #####
+        # These are all the spots where a rotation starts and end
+        warnings.simplefilter("ignore", category=ConsistencyWarning)
+        warnings.simplefilter("ignore", category=UserWarning)
+
+        depot_capacities_for_scenario: Dict[
+            Station, Dict[VehicleType, Dict[AreaType, int]]
+        ] = {}
+
+        num_rotations_for_scenario: Dict[Station, int] = {}
+
+        for (
+            first_last_stop_tup,
+            vehicle_type_dict,
+        ) in group_rotations_by_start_end_stop(scenario.id, session).items():
+            first_stop, last_stop = first_last_stop_tup
+            if first_stop != last_stop:
+                raise ValueError("First and last stop of a rotation are not the same.")
+
+            station = first_stop
+            rotation_count_depot = sum(
+                len(rotations) for vehicle_type, rotations in vehicle_type_dict.items()
+            )
+
+            savepoint = session.begin_nested()
+            try:
+                # (Temporarily) Delete all rotations not starting or ending at the station
+                logger.debug(
+                    f"Deleting all rotations not starting or ending at {station.name}"
+                )
+                all_rot_for_scenario = (
+                    session.query(Rotation)
+                    .filter(Rotation.scenario_id == scenario.id)
+                    .all()
+                )
+                to_delete = []
+                for rot in all_rot_for_scenario:
+                    first_stop = rot.trips[0].route.departure_station
+                    if first_stop != station:
+                        for trip in rot.trips:
+                            for stop_time in trip.stop_times:
+                                to_delete.append(stop_time)
+                            for event in trip.events:
+                                to_delete.append(event)
+                            to_delete.append(trip)
+                        to_delete.append(rot)
+                for obj in to_delete:
+                    session.flush()
+                    session.delete(obj)
+                    session.flush()
+
+                logger.info(f"Generating depot layout for station {station.name}")
+                vt_capacities_for_station = depot_smallest_possible_size(
+                    station,
+                    scenario,
+                    session,
+                    standard_block_length,
+                    charging_power,
+                )
+
+                depot_capacities_for_scenario[station] = vt_capacities_for_station
+                num_rotations_for_scenario[station] = rotation_count_depot
+            finally:
+                savepoint.rollback()
+
+    # create depot with the calculated area sizes
+
+    with create_session(scenario, database_url) as (session, scenario):
+        for depot_station, capacities in depot_capacities_for_scenario.items():
+            generate_depot(
+                capacities,
+                depot_station,
+                scenario,
+                session,
+                standard_block_length=standard_block_length,
+                charging_power=charging_power,
+                num_shunting_slots=num_rotations_for_scenario[depot_station] // 10,
+                num_cleaning_slots=num_rotations_for_scenario[depot_station] // 10,
+            )
+
+        # Delete all vehicles and events again. Only depot layout is kept
+
+        rotation_q = session.query(Rotation).filter(Rotation.scenario_id == scenario.id)
+        rotation_q.update({"vehicle_id": None})
+        session.query(Event).filter(Event.scenario_id == scenario.id).delete()
+        session.query(Vehicle).filter(Vehicle.scenario_id == scenario.id).delete()

{eflips_depot-4.9.1 → eflips_depot-4.11.0}/eflips/depot/api/private/consumption.py

@@ -1,9 +1,11 @@
 import logging
 import warnings
+from dataclasses import dataclass
 from datetime import timedelta, datetime
 from math import ceil
-from typing import Tuple
+from typing import Tuple, List
 from zoneinfo import ZoneInfo
+import scipy
 
 import numpy as np
 import sqlalchemy.orm
@@ -12,11 +14,281 @@ from eflips.model import (
     EventType,
     Rotation,
     Vehicle,
+    VehicleType,
+    VehicleClass,
     Trip,
     Station,
     ChargeType,
     ConsistencyWarning,
+    ConsumptionLut,
+    Scenario,
 )
+from sqlalchemy.orm import joinedload
+
+from eflips.depot.api.private.util import temperature_for_trip, create_session
+
+
+@dataclass
+class ConsumptionResult:
+    """
+    A dataclass that stores the results of a charging simulation for a single trip.
+
+    This class holds both the total change in battery State of Charge (SoC) over the trip
+    as well as an optional timeseries of timestamps and incremental SoC changes. When
+    an entry exists for a given trip in ``consumption_result``, the simulation will use
+    these precomputed values instead of recalculating the SoC changes from the vehicle
+    distance and consumption.
+
+    :param delta_soc_total:
+        The total change in the vehicle's State of Charge over the trip, typically
+        negative if the vehicle is consuming energy (e.g., -0.15 means the SoC
+        dropped by 15%).
+
+    :param timestamps:
+        A list of timestamps (e.g., arrival times at stops) that mark the times
+        associated with the SoC changes. The number of timestamps must match the
+        number of entries in ``delta_soc``.
+
+    :param delta_soc:
+        A list of cumulative SoC changes corresponding to the ``timestamps``.
+        For example, if ``delta_soc[i] = -0.02``, it means the SoC decreased by 2%
+        between from the start of the trip to ``timestamps[i]``. This list should typically
+        be a monotonic decreasing sequence.
+    """
+
+    delta_soc_total: float
+    timestamps: List[datetime] | None
+    delta_soc: List[float] | None
+
+
+@dataclass
+class ConsumptionInformation:
+    """
+    A dataclass to hold the information needed for the consumption simulation.
+
+    :param trip_id:
+        The ID of the trip for which the consumption is calculated.
+    :param consumption_lut:
+        The ConsumptionLut object for the vehicle class. This is used to calculate the
+        consumption based on the trip parameters.
+    :param average_speed:
+        The average speed of the trip in km/h. This is used to calculate the consumption.
+    :param distance:
+        The distance of the trip in km. This is used to calculate the total consumption.
+    :param temperature:
+        The ambient temperature in °C. This is used to calculate the consumption.
+    :param level_of_loading:
+        The level of loading of the vehicle as a fraction of its maximum payload.
+    :param incline:
+        The incline of the trip as a fraction (0.0-1.0). This is used to calculate the consumption.
+    :param consumption:
+        The total consumption of the trip in kWh. This is calculated based on the LUT and trip parameters.
+    :param consumption_per_km:
+        The consumption per km in kWh. This is calculated based on the LUT and trip parameters.
+    """
+
+    trip_id: int
+    consumption_lut: ConsumptionLut | None  # the LUT for the vehicle class
+    average_speed: float  # the average speed of the trip in km/h
+    distance: float  # the distance of the trip in km
+    temperature: float  # The ambient temperature in °C
+    level_of_loading: float
+    incline: float = 0.0  # The incline of the trip in 0.0-1.0
+    consumption: float = None  # The consumption of the trip in kWh
+    consumption_per_km: float = None  # The consumption per km in kWh
+
+    def calculate(self):
+        """
+        Calculates the consumption for the trip. Returns a float in kWh.
+
+        :return: The energy consumption in kWh. This is already the consumption for the whole trip.
+        """
+
+        # Make sure the consumption lut has 4 dimensions and the columns are in the correct order
+        if self.consumption_lut.columns != [
+            "incline",
+            "t_amb",
+            "level_of_loading",
+            "mean_speed_kmh",
+        ]:
+            raise ValueError(
+                "The consumption LUT must have the columns 'incline', 't_amb', 'level_of_loading', 'mean_speed_kmh'"
+            )
+
+        # Recover the scales along each of the four axes from the datapoints
+        incline_scale = sorted(set([x[0] for x in self.consumption_lut.data_points]))
+        temperature_scale = sorted(
+            set([x[1] for x in self.consumption_lut.data_points])
+        )
+        level_of_loading_scale = sorted(
+            set([x[2] for x in self.consumption_lut.data_points])
+        )
+        speed_scale = sorted(set([x[3] for x in self.consumption_lut.data_points]))
+
+        # Create the 4d array
+        consumption_lut = np.zeros(
+            (
+                len(incline_scale),
+                len(temperature_scale),
+                len(level_of_loading_scale),
+                len(speed_scale),
+            )
+        )
+
+        # Fill it with NaNs
+        consumption_lut.fill(np.nan)
+
+        for i, (incline, temperature, level_of_loading, speed) in enumerate(
+            self.consumption_lut.data_points
+        ):
+            consumption_lut[
+                incline_scale.index(incline),
+                temperature_scale.index(temperature),
+                level_of_loading_scale.index(level_of_loading),
+                speed_scale.index(speed),
+            ] = self.consumption_lut.values[i]
+
+        # Interpolate the consumption
+        interpolator = scipy.interpolate.RegularGridInterpolator(
+            (incline_scale, temperature_scale, level_of_loading_scale, speed_scale),
+            consumption_lut,
+            bounds_error=False,
+            fill_value=None,
+            method="linear",
+        )
+        consumption_per_km = interpolator(
+            [self.incline, self.temperature, self.level_of_loading, self.average_speed]
+        )[0]
+
+        # This is a temporary workaround to handle cases where the LUT does not contain
+        if consumption_per_km is None or np.isnan(consumption_per_km):
+            # Add a warning if we had to use nearest neighbor interpolation
+            warnings.warn(
+                f"Consumption LUT for trip {self.trip_id} with parameters: "
+                f"incline={self.incline}, temperature={self.temperature}, "
+                f"level_of_loading={self.level_of_loading}, average_speed={self.average_speed} "
+                f"returned NaN. Using nearest neighbor interpolation instead. The result may be less accurate.",
+                ConsistencyWarning,
+            )
+
+            interpolator_nn = scipy.interpolate.RegularGridInterpolator(
+                (incline_scale, temperature_scale, level_of_loading_scale, speed_scale),
+                consumption_lut,
+                bounds_error=False,
+                fill_value=None,  # Fill NaN with 0.0
+                method="nearest",
+            )
+            consumption_per_km = interpolator_nn(
+                [
+                    self.incline,
+                    self.temperature,
+                    self.level_of_loading,
+                    self.average_speed,
+                ]
+            )[0]
+
+            # Add a warning if we had to use nearest neighbor interpolation
+
+        if consumption_per_km is None or np.isnan(consumption_per_km):
+            raise ValueError(
+                f"Could not calculate consumption for trip {self.trip_id} with parameters: "
+                f"incline={self.incline}, temperature={self.temperature}, "
+                f"level_of_loading={self.level_of_loading}, average_speed={self.average_speed}. "
+                f"Possible reason: data points missing in the LUT."
+            )
+
+        self.consumption = consumption_per_km * self.distance
+        self.consumption_per_km = consumption_per_km
+        self.consumption_lut = None  # To save memory
+
+    def generate_consumption_result(self, battery_capacity) -> ConsumptionResult:
+        """
+        Generates a ConsumptionResult object from the current instance.
+
+        :param battery_capacity: The battery capacity in kWh.
+        :return: A ConsumptionResult object containing the total change in SoC and optional timeseries.
+        """
+        if self.consumption is None:
+            raise ValueError(
+                "Consumption must be calculated before generating a result."
+            )
+
+        # TODO implement a timeseries of timestamps and delta_soc
+        consumption_result = ConsumptionResult(
+            delta_soc_total=-float(self.consumption) / battery_capacity,
+            timestamps=None,
+            delta_soc=None,
+        )
+        return consumption_result
+
+
+def extract_trip_information(
+    trip_id: int,
+    scenario: Scenario,
+    passenger_mass=68,
+    passenger_count=17.6,
+) -> ConsumptionInformation:
+    """
+    Extracts the information needed for the consumption simulation from a trip.
+    """
+
+    with create_session(scenario) as (session, scenario):
+        # Load the trip with its route and rotation, including vehicle type and consumption LUT
+        # We use joinedload to avoid N+1 queries
+
+        trip = (
+            session.query(Trip)
+            .filter(Trip.id == trip_id)
+            .options(joinedload(Trip.route))
+            .options(
+                joinedload(Trip.rotation)
+                .joinedload(Rotation.vehicle_type)
+                .joinedload(VehicleType.vehicle_classes)
+                .joinedload(VehicleClass.consumption_lut)
+            )
+            .one()
+        )
+        # Check exactly one of the vehicle classes has a consumption LUT
+        all_consumption_luts = [
+            vehicle_class.consumption_lut
+            for vehicle_class in trip.rotation.vehicle_type.vehicle_classes
+        ]
+        all_consumption_luts = [x for x in all_consumption_luts if x is not None]
+        if len(all_consumption_luts) != 1:
+            raise ValueError(
+                f"Expected exactly one consumption LUT, got {len(all_consumption_luts)}"
+            )
+        consumption_lut = all_consumption_luts[0]
+        # Disconnect the consumption LUT from the session to avoid loading the whole table
+
+        del all_consumption_luts
+
+        total_distance = trip.route.distance / 1000  # km
+        total_duration = (
+            trip.arrival_time - trip.departure_time
+        ).total_seconds() / 3600
+        average_speed = total_distance / total_duration  # km/h
+
+        temperature = temperature_for_trip(trip_id, session)
+
+        payload_mass = passenger_mass * passenger_count
+        full_payload = (
+            trip.rotation.vehicle_type.allowed_mass
+            - trip.rotation.vehicle_type.empty_mass
+        )
+        level_of_loading = payload_mass / full_payload
+
+        info = ConsumptionInformation(
+            trip_id=trip.id,
+            consumption_lut=consumption_lut,
+            average_speed=average_speed,
+            distance=total_distance,
+            temperature=temperature,
+            level_of_loading=level_of_loading,
+        )
+
+        info.calculate()
+    return info
 
 
 def initialize_vehicle(rotation: Rotation, session: sqlalchemy.orm.session.Session):

{eflips_depot-4.9.1 → eflips_depot-4.11.0}/eflips/depot/api/private/depot.py

@@ -1070,7 +1070,8 @@ def depot_smallest_possible_size(
                         logger.debug(
                             f"Vehicle count for {vt.name} in {amount_of_line_areas} line areas configuration: {vehicle_count_q}. This is > than the all-direct configuration ({vehicle_counts_all_direct[vt]})."
                         )
-                except ValueError as e:
+                except Exception as e:
+                    # This change is made after Unstable exception and delay exceptions are introduced
                     if (
                         "which suggests the fleet or the infrastructure might not be enough for the full electrification. Please add charging interfaces or increase charging power ."
                         in repr(e)

{eflips_depot-4.9.1 → eflips_depot-4.11.0}/eflips/depot/api/private/results_to_database.py

@@ -67,7 +67,7 @@ def get_finished_schedules_per_vehicle(
             }
             if i == 0:
                 raise UnstableSimulationException(
-                    f"New Vehicle required for the trip {current_trip.ID}, which suggests the fleet or the "
+                    f"New Vehicle required for the rotation/block {current_trip.ID}, which suggests the fleet or the "
                     f"infrastructure might not be enough for the full electrification. Please add charging "
                     f"interfaces or increase charging power ."
                 )

{eflips_depot-4.9.1 → eflips_depot-4.11.0}/eflips/depot/api/private/util.py

@@ -7,6 +7,7 @@ from datetime import timedelta, datetime
 from typing import Union, Any, Optional, Tuple, Dict, List
 
 import simpy
+import numpy as np
 from eflips.model import (
     Scenario,
     VehicleType,
@@ -15,6 +16,7 @@ from eflips.model import (
     EventType,
     Trip,
     Depot,
+    Temperatures,
 )
 from sqlalchemy import inspect, create_engine
 from sqlalchemy.orm import Session
@@ -199,6 +201,38 @@ def check_depot_validity(depot: Depot) -> None:
         ), "All processes except the last one must have electric power."
 
 
+def temperature_for_trip(trip_id: int, session: Session) -> float:
+    """
+    Returns the temperature for a trip. Finds the temperature for the mid-point of the trip.
+
+    :param trip_id: The ID of the trip
+    :param session: The SQLAlchemy session
+    :return: A temperature in °C
+    """
+
+    trip = session.query(Trip).filter(Trip.id == trip_id).one()
+    temperatures = (
+        session.query(Temperatures)
+        .filter(Temperatures.scenario_id == trip.scenario_id)
+        .one()
+    )
+
+    # Find the mid-point of the trip
+    mid_time = trip.departure_time + (trip.arrival_time - trip.departure_time) / 2
+
+    if temperatures.use_only_time:
+        # The temperatures are only given by time. We change our mid-time to be the date of the temperatures
+        mid_time = datetime.combine(temperatures.datetimes[0].date(), mid_time.time())
+
+    mid_time = mid_time.timestamp()
+
+    datetimes = [dt.timestamp() for dt in temperatures.datetimes]
+    temperatures = temperatures.data
+
+    temperature = np.interp(mid_time, datetimes, temperatures)
+    return float(temperature)
+
+
 @dataclass
 class VehicleSchedule:
     """

{eflips_depot-4.9.1 → eflips_depot-4.11.0}/eflips/depot/depot.py

@@ -1514,6 +1514,10 @@ class DepotControl:
 
     def schedule_for_matching(self, trip):
         """Wait *delay* and then schedule *trip* for matching with a vehicle."""
+
+        # Shuyao: This delay does not mean the trip is delayed. It means the trip must be scheduled one hour before departure
+        # so the time of the environment is "delayed" until 1 hour before departure.
+
         delay = self.dispatch_strategy.scheduling_delay(self.env, trip)
         yield self.env.timeout(delay)
         self.depot.unassigned_trips.append(trip)

{eflips_depot-4.9.1 → eflips_depot-4.11.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "eflips-depot"
-version = "4.9.1"
+version = "4.11.0"
 description = "Depot Simulation for eFLIPS"
 authors = ["Enrico Lauth <enrico.lauth@tu-berlin.de>",
     "Ludger Heide <ludger.heide@tu-berlin.de",