eflips-depot 4.13.5__tar.gz → 4.14.0__tar.gz

{eflips_depot-4.13.5 → eflips_depot-4.14.0}/PKG-INFO

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: eflips-depot
-Version: 4.13.5
+Version: 4.14.0
 Summary: Depot Simulation for eFLIPS
 License: AGPL-3.0-or-later
+License-File: LICENSE.md
 Author: Enrico Lauth
 Author-email: enrico.lauth@tu-berlin.de
 Requires-Python: >=3.11,<3.14

{eflips_depot-4.13.5 → eflips_depot-4.14.0}/eflips/depot/__init__.py

@@ -52,46 +52,3 @@ from eflips.depot.simulation import (
 from eflips.depot.smart_charging import SmartCharging, ControlSmartCharging
 from eflips.depot.standalone import VehicleGenerator, SimpleTrip, Timetable
 from eflips.depot.validation import Validator
-
-
-class DelayedTripException(Exception):
-    def __init__(self):
-        self._delayed_trips = []
-
-    def raise_later(self, simple_trip):
-        self._delayed_trips.append(simple_trip)
-
-    @property
-    def has_errors(self):
-        return len(self._delayed_trips) > 0
-
-    def __str__(self):
-        trip_names = ", ".join(
-            f"{trip.ID} originally departure at {trip.std}"
-            for trip in self._delayed_trips
-        )
-
-        return (
-            f"The following blocks/rotations are delayed. "
-            f"Ignoring this error will write related depot events into database. However, this may lead to errors due "
-            f"to conflicts with driving events: {trip_names}"
-        )
-
-
-class UnstableSimulationException(Exception):
-    def __init__(self):
-        self._unstable_trips = []
-
-    def raise_later(self, simple_trip):
-        self._unstable_trips.append(simple_trip)
-
-    @property
-    def has_errors(self):
-        return len(self._unstable_trips) > 0
-
-    def __str__(self):
-        trip_names = ", ".join(trip.ID for trip in self._unstable_trips)
-        return (
-            f"The following blocks/rotations require a new vehicle. This suggests an unstable "
-            f" simulation result, where a repeated schedule might require more vehicles: {trip_names}"
-        )

{eflips_depot-4.13.5 → eflips_depot-4.14.0}/eflips/depot/api/__init__.py

@@ -32,7 +32,8 @@ from collections import OrderedDict
 from datetime import timedelta, datetime
 from enum import Enum
 from math import ceil
-from typing import Any, Dict, Optional, Union
+from typing import Any, Dict, Optional, Union, List
+
 
 import sqlalchemy.orm
 from eflips.model import (
@@ -58,8 +59,6 @@ import eflips.depot
 from eflips.depot import (
     DepotEvaluation,
     SimulationHost,
-    UnstableSimulationException,
-    DelayedTripException,
 )
 from eflips.depot.api.private.consumption import ConsumptionResult
 from eflips.depot.api.private.consumption import (
@@ -74,6 +73,7 @@ from eflips.depot.api.private.depot import (
     group_rotations_by_start_end_stop,
     generate_depot,
     depot_smallest_possible_size,
+    create_depots_from_wish,
 )
 from eflips.depot.api.private.results_to_database import (
     get_finished_schedules_per_vehicle,
@@ -83,6 +83,8 @@ from eflips.depot.api.private.results_to_database import (
     add_events_into_database,
     update_vehicle_in_rotation,
     update_waiting_events,
+    UnstableSimulationException,
+    DelayedTripException,
 )
 from eflips.depot.api.private.util import (
     create_session,
@@ -93,6 +95,8 @@ from eflips.depot.api.private.util import (
     check_depot_validity,
 )
 
+from eflips.depot.api.private.depot import AreaInformation, DepotConfigurationWish
+
 
 class SmartChargingStrategy(Enum):
     """Enum class for different smart charging strategies."""
@@ -636,6 +640,8 @@ def simulate_scenario(
             repetition_period=repetition_period,
         )
         ev = run_simulation(simulation_host)
+
+        errors = []
         try:
             add_evaluation_to_database(scenario, ev, session)
 
@@ -645,14 +651,19 @@ def simulate_scenario(
                     "There are delayed trips in the simulation. "
                     "Please check the input data and try again."
                 )
-                raise delay_exp
+                errors.append(delay_exp.exceptions[0])
         except* UnstableSimulationException as unstable_exp:
             if not ignore_unstable_simulation:
                 logger.error(
                     "The simulation became unstable. "
                     "Please check the input data and try again."
                 )
-                raise unstable_exp
+                errors.append(unstable_exp.exceptions[0])
+
+        # There will be exactly one UnstableSimulationException or DelayedTripException in the list.
+        # Only the DelayedTripException will be raised if both exceptions are in the list.
+        for e in errors:
+            raise e
 
         match smart_charging_strategy:
             case SmartChargingStrategy.NONE:
@@ -1000,6 +1011,10 @@ def add_evaluation_to_database(
 
     # Read simulation start time
 
+    unstable_exp = UnstableSimulationException()
+    delay_exp = DelayedTripException()
+    errors = []
+
     for depot_id, depot_evaluation in depot_evaluations.items():
         simulation_start_time = depot_evaluation.sim_start_datetime
 
@@ -1019,9 +1034,6 @@ def add_evaluation_to_database(
             f"one waiting area."
         )
 
-        unstable_exp = UnstableSimulationException()
-        delay_exp = DelayedTripException()
-
         for current_vehicle in depot_evaluation.vehicle_generator.items:
             # Vehicle-layer operations
 
@@ -1086,17 +1098,15 @@ def add_evaluation_to_database(
         update_vehicle_in_rotation(session, scenario, list_of_assigned_schedules)
         update_waiting_events(session, scenario, waiting_area_id)
 
-        errors = []
+    if delay_exp.has_errors:
+        errors.append(delay_exp)
+    if unstable_exp.has_errors:
+        errors.append(unstable_exp)
 
-        if delay_exp.has_errors:
-            errors.append(delay_exp)
-        if unstable_exp.has_errors:
-            errors.append(unstable_exp)
-
-        if len(errors) > 0:
-            raise ExceptionGroup(
-                "Simulation is either unstable or including delayed blocks", errors
-            )
+    if len(errors) > 0:
+        raise ExceptionGroup(
+            "Simulation is either unstable or including delayed blocks", errors
+        )
 
 
 def generate_depot_optimal_size(
@@ -1334,3 +1344,162 @@ def schedule_duration_days(
         duration_days = ceil(duration.total_seconds() / (24 * 60 * 60))
 
         return timedelta(days=duration_days)
+
+
+def auto_generate_depot_inplace(
+    depot_wish: DepotConfigurationWish,
+    session,
+    scenario,
+) -> None:
+    """
+    This method calculates an optimal depot layout for auto-generated depots and modifies the instance of
+    :class:`eflips.depot.api.private.depot.DepotConfigurationWish` objects in place.
+
+    :param depot_wish: a :class:`eflips.depot.api.private.depot.DepotConfigurationWish` object. It represents a depot to be generated by eflips calulation.
+    :param session: a :class:'sqlalchemy.orm.Session' object.
+    :param scenario: a :class:`eflips.model.Scenario` object containing the input data for the simulation.
+    :return: None. The depot layout will be written inplace to the depot_wish object.
+    """
+    logger = logging.getLogger(__name__)
+
+    station = session.query(Station).filter(Station.id == depot_wish.station_id).one()
+
+    warnings.simplefilter("ignore", category=ConsistencyWarning)
+    warnings.simplefilter("ignore", category=UserWarning)
+
+    inner_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)
+                    to_delete.append(trip)
+                to_delete.append(rot)
+
+        # debugging
+        for obj in to_delete:
+            session.flush()
+            session.delete(obj)
+            session.flush()
+
+        # Consumption simulation for rotations of this depot
+
+        consumption_results = generate_consumption_result(scenario)
+        simple_consumption_simulation(
+            scenario,
+            initialize_vehicles=True,
+            consumption_result=consumption_results,
+        )
+
+        logger.info(f"Generating depot layout for station {station.name}")
+        vt_capacities_for_station = depot_smallest_possible_size(
+            station,
+            scenario,
+            session,
+            depot_wish.standard_block_length,
+            depot_wish.default_power,
+        )
+
+        area_list: List[AreaInformation] = []
+
+        for vt, capacity in vt_capacities_for_station.items():
+            if capacity[AreaType.LINE] > 0:
+                area_list.append(
+                    AreaInformation(
+                        area_type=AreaType.LINE,
+                        capacity=capacity[AreaType.LINE],
+                        block_length=depot_wish.standard_block_length,
+                        power=depot_wish.default_power,
+                        vehicle_type_id=vt.id,
+                    )
+                )
+
+            if capacity[AreaType.DIRECT_ONESIDE] > 0:
+                area_list.append(
+                    AreaInformation(
+                        area_type=AreaType.DIRECT_ONESIDE,
+                        capacity=capacity[AreaType.DIRECT_ONESIDE],
+                        block_length=None,
+                        power=depot_wish.default_power,
+                        vehicle_type_id=vt.id,
+                    )
+                )
+
+        depot_wish.areas = area_list
+
+    finally:
+        inner_savepoint.rollback()
+
+    session.expire_all()
+
+
+def generate_optimal_depot_layout(
+    depot_config_wishes: List[DepotConfigurationWish],
+    scenario: Union[Scenario, int, Any],
+    database_url: Optional[str] = None,
+    delete_existing_depot: bool = False,
+) -> None:
+    """
+
+    :param depot_config_wishes: a list of :class:`eflips.depot.api.private.depot.DepotConfigurationWish` objects.
+    :param scenario: Either a :class:`eflips.model.Scenario` object containing the input data for the simulation. Or
+        an integer specifying the ID of a scenario in the database. Or any other object that has an attribute "id" containing
+        an integer pointing to a unique scenario id.
+    :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
+    :return: None. The depot layout will be added to the database.
+    """
+
+    with create_session(scenario, database_url) as (session, scenario):
+        # Delete all depot events
+        session.query(Event).filter(
+            Event.scenario_id == scenario.id, Event.area_id.isnot(None)
+        ).delete()
+
+        if session.query(Depot).filter(Depot.scenario_id == scenario.id).count() != 0:
+            if delete_existing_depot is False:
+                raise ValueError(
+                    "Depot already exists. Set delete_existing_depot to True to delete it."
+                )
+
+            delete_depots(scenario, session)
+
+        # Group all the rotations by their start and end stop (depot)
+
+        grouped_rotations = group_rotations_by_start_end_stop(scenario.id, session)
+        assert len(grouped_rotations) == len(depot_config_wishes), (
+            "The number of depot configuration wishes must be equal to the number of depots in the scenario."
+            f"Found {len(depot_config_wishes)} wishes and {len(grouped_rotations)} depots."
+        )
+
+        savepoint = session.begin_nested()
+
+        # 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()
+        session.expire_all()
+        for depot_wish in depot_config_wishes:
+            if depot_wish.auto_generate is False:
+                continue
+
+            auto_generate_depot_inplace(
+                depot_wish,
+                session,
+                scenario,
+            )
+
+        savepoint.rollback()
+        create_depots_from_wish(
+            depot_config_wishes, grouped_rotations, scenario, session
+        )

{eflips_depot-4.13.5 → eflips_depot-4.14.0}/eflips/depot/api/private/depot.py

@@ -4,6 +4,7 @@ import math
 from datetime import timedelta
 from enum import Enum, auto
 from typing import Dict, List, Tuple, Optional
+from dataclasses import dataclass
 
 import numpy as np
 import sqlalchemy.orm
@@ -27,13 +28,120 @@ from eflips.model import (
 from sqlalchemy import or_
 from sqlalchemy.orm import Session
 
-from eflips.depot import UnstableSimulationException, DelayedTripException
+from eflips.depot.api.private.results_to_database import (
+    UnstableSimulationException,
+    DelayedTripException,
+)
 
 
 class MissingVehicleDimensionError(ValueError):
     pass
 
 
+@dataclass
+class AreaInformation:
+    """ """
+
+    area_type: AreaType
+    """
+    Type of the area, defined in AreaType enum.
+    """
+    capacity: int
+    """Capacity of the area."""
+    block_length: int | None
+    """Block length of the area in meters. Only needed for AreaType.LINE."""
+    power: float
+    """Charging power of the area in kW."""
+    vehicle_type_id: int
+    """Vehicle type ID of the area."""
+
+    def __init__(self, area_type, capacity, power, vehicle_type_id, block_length=None):
+        self.area_type = area_type
+        self.capacity = capacity
+        self.block_length = block_length
+        self.power = power
+        self.vehicle_type_id = vehicle_type_id
+        # do some simple validation here
+        if self.area_type == AreaType.LINE and (
+            self.block_length is None
+            or self.block_length <= 0
+            or self.capacity % self.block_length != 0
+        ):
+            raise ValueError(
+                "Block length must be a positive integer for LINE areas, "
+                "and must be multiple of the standard block length."
+            )
+        if self.area_type != AreaType.LINE and self.block_length is not None:
+            raise ValueError("Block length must be None for non-LINE areas.")
+
+        if self.capacity <= 0:
+            raise ValueError("Capacity must be a positive integer.")
+        if self.power <= 0:
+            raise ValueError("Power must be a positive float.")
+        if self.vehicle_type_id <= 0:
+            raise ValueError("Vehicle type ID must be a positive integer.")
+
+
+@dataclass
+class DepotConfigurationWish:
+
+    """ """
+
+    station_id: int
+    """
+    ID of the station where the depot should be located.
+    """
+    auto_generate: bool
+    """
+    True if the depot should be auto-generated, False if the depot should be created from user input.
+    """
+    default_power: float | None
+    standard_block_length: int | None
+    cleaning_slots: int | None
+    cleaning_duration: timedelta | None
+    shunting_slots: int | None
+    shunting_duration: timedelta | None
+    areas: list[AreaInformation] | None  #
+
+    def __init__(
+        self,
+        station_id,
+        auto_generate: bool = False,
+        default_power: float | None = None,
+        standard_block_length: int | None = None,
+        cleaning_slots: int | None = None,
+        cleaning_duration: timedelta | None = None,
+        shunting_slots: int | None = None,
+        shunting_duration: timedelta | None = None,
+        areas: list[AreaInformation] | None = None,
+    ):
+        self.station_id = station_id
+        self.auto_generate = auto_generate
+        self.default_power = default_power
+        self.standard_block_length = standard_block_length
+        self.cleaning_slots = cleaning_slots
+        self.cleaning_duration = cleaning_duration
+        self.shunting_slots = shunting_slots
+        self.shunting_duration = shunting_duration
+        self.areas = areas
+
+        if self.auto_generate is True:
+            if self.default_power is None or self.standard_block_length is None:
+                raise ValueError(
+                    "If auto_generate is True, default_power, standard_block_length, cleaning_slots, cleaning_duration and shunting_slots must be provided."
+                )
+            if (
+                self.cleaning_slots is not None
+                or self.cleaning_duration is not None
+                or self.shunting_slots is not None
+                or self.shunting_duration is not None
+            ):
+                raise ValueError(
+                    "If auto_generate is True, default_power, standard_block_length, cleaning_slots, cleaning_duration and shunting_slots cannot be provided."
+                )
+        # do some simple validation here
+
+
 def delete_depots(scenario: Scenario, session: Session) -> None:
     """This function deletes all depot-related data from the database for a given scenario.
 
@@ -1117,3 +1225,257 @@ def depot_smallest_possible_size(
         return ret_val
     finally:
         outer_savepoint.rollback()
+
+
+def estimate_service_capacity(
+    all_rotations_this_depot: List[Rotation], service_duration: timedelta
+) -> int:
+    """
+    Estimate the number of service slots needed based on the rotations and a given service duration.
+    It is estimated as the maximum arrivals in the time window of the service duration.
+    :param all_rotations_this_depot: A list of all rotations starting and ending at the depot's station.
+    :param service_duration: A timedelta representing the duration of the service.
+    :return: Estimated number of service slots needed without waiting.
+    """
+    if not all_rotations_this_depot:
+        return 0
+
+    # Sort by the first trip’s departure time
+    all_rotations_this_depot.sort(key=lambda r: r.trips[0].arrival_time)
+
+    max_arrivals = 0
+    left = 0
+
+    # Sliding window: move right pointer
+    for right, rotation in enumerate(all_rotations_this_depot):
+        start_time = rotation.trips[0].departure_time
+
+        # Shrink window from the left until within service_duration
+        while (
+            start_time - all_rotations_this_depot[left].trips[0].departure_time
+            > service_duration
+        ):
+            left += 1
+
+        # Window size = number of rotations within the service duration
+        max_arrivals = max(max_arrivals, right - left + 1)
+
+    return max_arrivals
+
+
+def create_depots_from_wish(
+    depot_config_wishes: List[DepotConfigurationWish],
+    grouped_rotations: Dict[Tuple[Station, Station], Dict[VehicleType, List[Rotation]]],
+    scenario: Scenario,
+    session: Session,
+) -> None:
+    """
+    This function only creates depots and their areas based on the provided configuration wishes. the result will be
+    written into the database.
+
+    :param depot_config_wishes: A list of depot configuration wishes.
+    :param grouped_rotations: A dictionary of grouped rotations by (start_station, end_station)
+    :param scenario: The scenario to be simulated.
+    :param session: An open SQLAlchemy session.
+    :return: None. The depots are added to the database.
+    """
+    for depot_wish in depot_config_wishes:
+        station = (
+            session.query(Station).filter(Station.id == depot_wish.station_id).one()
+        )
+        depot = Depot(
+            scenario=scenario,
+            name=f"Depot at {station.name}",
+            name_short=station.name_short,
+            station_id=station.id,
+        )
+        session.add(depot)
+
+        plan = Plan(scenario=scenario, name=f"Default Plan")
+        session.add(plan)
+
+        depot.default_plan = plan
+
+        all_rotations_with_type = grouped_rotations[station, station]
+        all_rotations_this_depot = [
+            r for vt, rotations in all_rotations_with_type.items() for r in rotations
+        ]
+
+        # Create processes
+
+        plan_process_assocs: List[AssocPlanProcess] = []
+
+        if depot_wish.shunting_duration is None:
+            shunting_duration = timedelta(minutes=5)
+        else:
+            shunting_duration = depot_wish.shunting_duration
+        if depot_wish.cleaning_duration is None:
+            cleaning_duration = timedelta(minutes=30)
+        else:
+            cleaning_duration = depot_wish.cleaning_duration
+
+        if depot_wish.shunting_slots is None:
+            shunting_slots = estimate_service_capacity(
+                all_rotations_this_depot, shunting_duration
+            )
+        else:
+            shunting_slots = depot_wish.shunting_slots
+        shunting_1 = Process(
+            name="Shunting 1",
+            scenario=scenario,
+            dispatchable=False,
+            duration=shunting_duration,
+        )
+        session.add(shunting_1)
+        shunting_area_1 = Area(
+            scenario=scenario,
+            name=f"Shunting Area 1",
+            depot=depot,
+            area_type=AreaType.DIRECT_ONESIDE,
+            vehicle_type=None,  # Meaning any vehicle type can be shunted here
+            capacity=shunting_slots,
+        )
+        session.add(shunting_area_1)
+        shunting_area_1.processes.append(shunting_1)
+        plan_process_assocs.append(
+            AssocPlanProcess(
+                scenario=scenario,
+                process=shunting_1,
+                plan=plan,
+                ordinal=len(plan_process_assocs),
+            )
+        )
+
+        if depot_wish.cleaning_slots is None:
+            cleaning_slots = estimate_service_capacity(
+                all_rotations_this_depot, cleaning_duration
+            )
+        else:
+            cleaning_slots = depot_wish.cleaning_slots
+        clean = Process(
+            name="Arrival Cleaning",
+            scenario=scenario,
+            dispatchable=False,
+            duration=cleaning_duration,
+        )
+        session.add(clean)
+        cleaning_area = Area(
+            scenario=scenario,
+            name=f"Cleaning Area",
+            depot=depot,
+            area_type=AreaType.DIRECT_ONESIDE,
+            vehicle_type=None,  # Meaning any vehicle type can be cleaned here
+            capacity=cleaning_slots,
+        )
+        session.add(cleaning_area)
+        cleaning_area.processes.append(clean)
+        plan_process_assocs.append(
+            AssocPlanProcess(
+                scenario=scenario,
+                process=clean,
+                plan=plan,
+                ordinal=len(plan_process_assocs),
+            )
+        )
+
+        shunting_2 = Process(
+            name="Shunting 2",
+            scenario=scenario,
+            dispatchable=False,
+            duration=shunting_duration,
+        )
+        session.add(shunting_2)
+        shunting_area_2 = Area(
+            scenario=scenario,
+            name=f"Shunting Area 2",
+            depot=depot,
+            area_type=AreaType.DIRECT_ONESIDE,
+            vehicle_type=None,  # Meaning any vehicle type can be shunted here
+            capacity=shunting_slots,
+        )
+        session.add(shunting_area_2)
+        shunting_area_2.processes.append(shunting_2)
+        plan_process_assocs.append(
+            AssocPlanProcess(
+                scenario=scenario,
+                process=shunting_2,
+                plan=plan,
+                ordinal=len(plan_process_assocs),
+            )
+        )
+
+        # TODO: we only do constant charging power per depot for now. Might be possible in the future to have different
+        # powers per area
+
+        if depot_wish.auto_generate:
+            charging_power = depot_wish.default_power
+        else:
+            charging_power = depot_wish.areas[0].power
+
+        charging = Process(
+            name="Charging",
+            scenario=scenario,
+            dispatchable=True,
+            electric_power=charging_power,
+        )
+        session.add(charging)
+        plan_process_assocs.append(
+            AssocPlanProcess(
+                scenario=scenario,
+                process=charging,
+                plan=plan,
+                ordinal=len(plan_process_assocs),
+            )
+        )
+
+        standby_departure = Process(
+            name="Standby Pre-departure",
+            scenario=scenario,
+            dispatchable=True,
+        )
+        session.add(standby_departure)
+        plan_process_assocs.append(
+            AssocPlanProcess(
+                scenario=scenario,
+                process=standby_departure,
+                plan=plan,
+                ordinal=len(plan_process_assocs),
+            )
+        )
+        session.add_all(plan_process_assocs)  # It's complete, so add all at once
+
+        # Create shared waiting area
+        rotation_count = len(
+            session.query(Rotation).filter(Rotation.scenario_id == scenario.id).all()
+        )
+
+        waiting_area = Area(
+            scenario=scenario,
+            name=f"Waiting Area for every type of vehicle",
+            depot=depot,
+            area_type=AreaType.DIRECT_ONESIDE,
+            capacity=rotation_count * 4,
+            # Initialize with 4 times of rotation count because all rotations are copied three times. Assuming each rotation needs a vehicle.
+        )
+        session.add(waiting_area)
+
+        for area_info in depot_wish.areas:
+            area = Area(
+                scenario=scenario,
+                name=f"{area_info.area_type.name} Area for {session.query(VehicleType).filter(VehicleType.id == area_info.vehicle_type_id).one().name_short}",
+                depot=depot,
+                area_type=area_info.area_type,
+                vehicle_type_id=area_info.vehicle_type_id,
+                capacity=area_info.capacity,
+                row_count=(
+                    area_info.capacity // area_info.block_length
+                    if area_info.area_type == AreaType.LINE
+                    and area_info.block_length is not None
+                    else None
+                ),
+            )
+            area.processes.append(charging)
+            area.processes.append(standby_departure)
+            session.add(area)
+
+        session.flush()

{eflips_depot-4.13.5 → eflips_depot-4.14.0}/eflips/depot/api/private/results_to_database.py

@@ -10,7 +10,49 @@ from eflips.model import Event, EventType, Rotation, Vehicle, Area, AreaType
 from sqlalchemy import select
 
 from eflips.depot import SimpleVehicle, ProcessStatus
-from eflips.depot import UnstableSimulationException, DelayedTripException
+
+
+class DelayedTripException(Exception):
+    def __init__(self):
+        self._delayed_trips = []
+
+    def raise_later(self, simple_trip):
+        self._delayed_trips.append(simple_trip)
+
+    @property
+    def has_errors(self):
+        return len(self._delayed_trips) > 0
+
+    def __str__(self):
+        trip_names = ", ".join(
+            f"{trip.ID} originally departure at {trip.std}"
+            for trip in self._delayed_trips
+        )
+
+        return (
+            f"The following blocks/rotations are delayed. "
+            f"Ignoring this error will write related depot events into database. However, this may lead to errors due "
+            f"to conflicts with driving events: {trip_names}"
+        )
+
+
+class UnstableSimulationException(Exception):
+    def __init__(self):
+        self._unstable_trips = []
+
+    def raise_later(self, simple_trip):
+        self._unstable_trips.append(simple_trip)
+
+    @property
+    def has_errors(self):
+        return len(self._unstable_trips) > 0
+
+    def __str__(self):
+        trip_names = ", ".join(str(trip.ID) for trip in self._unstable_trips)
+        return (
+            f"The following blocks/rotations require a new vehicle. This suggests an unstable "
+            f" simulation result, where a repeated schedule might require more vehicles: {trip_names}"
+        )
 
 
 def get_finished_schedules_per_vehicle(
@@ -554,13 +596,15 @@ def update_waiting_events(session, scenario, waiting_area_id) -> None:
         all_waiting_ends
     ), f"Number of waiting events starts {len(all_waiting_starts)} is not equal to the number of waiting event ends"
 
-    if len(all_waiting_starts) == 0:
+    BUFFER_WAITING_CAPACITY = 1
+
+    if len(all_waiting_starts) < BUFFER_WAITING_CAPACITY:
         logger.info(
-            "No waiting events found. The depot has enough capacity for waiting. Change the waiting area capacity to 10 as buffer."
+            f"{all_waiting_starts} waiting events found. The depot has enough capacity for waiting. Change the waiting area capacity to {BUFFER_WAITING_CAPACITY} as buffer."
         )
 
         session.query(Area).filter(Area.id == waiting_area_id).update(
-            {"capacity": 10}, synchronize_session="auto"
+            {"capacity": BUFFER_WAITING_CAPACITY}, synchronize_session="auto"
         )
 
         return

{eflips_depot-4.13.5 → eflips_depot-4.14.0}/pyproject.toml

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