eflips-depot 4.13.0__tar.gz → 4.13.2__tar.gz

{eflips_depot-4.13.0 → eflips_depot-4.13.2}/PKG-INFO

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

{eflips_depot-4.13.0 → eflips_depot-4.13.2}/eflips/depot/__init__.py

@@ -54,9 +54,49 @@ 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):
-    pass
+    def __init__(self):
+        self._unstable_trips = []
 
+    def raise_later(self, simple_trip):
+        self._unstable_trips.append(simple_trip)
 
-class DelayedTripException(Exception):
-    pass
+    @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}"
+        )
+
+
+class MultipleErrors(Exception):
+    def __init__(self, errors):
+        self.errors = errors

{eflips_depot-4.13.0 → eflips_depot-4.13.2}/eflips/depot/api/__init__.py

@@ -29,11 +29,10 @@ import logging
 import os
 import warnings
 from collections import OrderedDict
-from dataclasses import dataclass
 from datetime import timedelta, datetime
 from enum import Enum
 from math import ceil
-from typing import Any, Dict, Optional, Union, List
+from typing import Any, Dict, Optional, Union
 
 import sqlalchemy.orm
 from eflips.model import (
@@ -51,14 +50,17 @@ from eflips.model import (
     Route,
     ConsistencyWarning,
     Station,
-    ConsumptionLut,
 )
+from sqlalchemy import func
 from sqlalchemy.orm import Session
 
 import eflips.depot
 from eflips.depot import (
     DepotEvaluation,
     SimulationHost,
+    UnstableSimulationException,
+    DelayedTripException,
+    MultipleErrors,
 )
 from eflips.depot.api.private.consumption import ConsumptionResult
 from eflips.depot.api.private.consumption import (
@@ -637,16 +639,30 @@ def simulate_scenario(
         ev = run_simulation(simulation_host)
         try:
             add_evaluation_to_database(scenario, ev, session)
-        except eflips.depot.UnstableSimulationException as e:
-            if ignore_unstable_simulation:
-                logger.warning("Simulation is unstable. Continuing.")
-            else:
-                raise e
-        except eflips.depot.DelayedTripException as e:
-            if ignore_delayed_trips:
-                logger.warning("Simulation has delayed trips. Continuing.")
-            else:
-                raise e
+
+        except MultipleErrors as e:
+            if e.errors:
+                for error in e.errors:
+                    if (
+                        isinstance(error, DelayedTripException)
+                        and not ignore_delayed_trips
+                    ):
+                        logger.error(
+                            "There are delayed trips in the simulation. "
+                            "Please check the input data and try again."
+                        )
+                        raise error
+                    if (
+                        isinstance(error, UnstableSimulationException)
+                        and not ignore_unstable_simulation
+                    ):
+                        logger.error(
+                            "Simulation became unstable. "
+                            "Please check the input data and try again."
+                        )
+                        raise error
+
+                    logger.warning("An error occurred during the simulation: %s", error)
 
         match smart_charging_strategy:
             case SmartChargingStrategy.NONE:
@@ -746,28 +762,15 @@ def init_simulation(
         .all()
     ]
 
-    first_departure_time = min(
-        [vehicle_schedule.departure for vehicle_schedule in vehicle_schedules]
-    )
-    last_arrival_time = max(
-        [vehicle_schedule.arrival for vehicle_schedule in vehicle_schedules]
-    )
-
-    # We take first arrival time as simulation start
-    total_duration = (last_arrival_time - first_departure_time).total_seconds()
-    schedule_duration_days = ceil(total_duration / (24 * 60 * 60))
-
-    if repetition_period is None and schedule_duration_days in [1, 2]:
-        repetition_period = timedelta(days=1)
-    elif repetition_period is None and schedule_duration_days in [7, 8]:
-        repetition_period = timedelta(weeks=1)
-    elif repetition_period is None:
-        raise ValueError(
-            "Could not automatically detect repetition period. Please specify manually."
-        )
+    if repetition_period is None:
+        repetition_period = schedule_duration_days(scenario)
+        if repetition_period not in (timedelta(days=1), timedelta(days=7)):
+            warnings.warn(
+                f"Non-standard schedule duration of {repetition_period}. Please make sure this is intended.",
+                UserWarning,
+            )
 
     # Now, we need to repeat the vehicle schedules
-
     vehicle_schedules = repeat_vehicle_schedules(vehicle_schedules, repetition_period)
 
     sim_start_stime, total_duration_seconds = start_and_end_times(vehicle_schedules)
@@ -784,6 +787,8 @@ def init_simulation(
     # Clear old vehicle counts, if they exist
     eflips.globalConstants["depot"]["vehicle_count"] = {}
 
+    grouped_rotations = group_rotations_by_start_end_stop(scenario.id, session)
+
     # We need to calculate roughly how many vehicles we need for each depot
     for depot in session.query(Depot).filter(Depot.scenario_id == scenario.id).all():
         depot_id = str(depot.id)
@@ -806,31 +811,32 @@ def init_simulation(
                 depot_id
             ] = vehicle_count_dict[depot_id]
         else:
-            # Calculate it from the size of the charging area with a 2x margin
+            # Calculate it from the amount of rotations with a 4x margin because 4 times of repetition
+            # in repeat_vehicle_schedules()
+            rotations = grouped_rotations[(depot.station, depot.station)]
 
             for vehicle_type in vehicle_types_for_depot:
-                vehicle_count = 0
-                for area in depot.areas:
-                    if (
-                        area.vehicle_type_id == int(vehicle_type)
-                        or area.vehicle_type_id is None
-                    ):
-                        # The areas allow either one type, or all vehicle types
-                        for p in area.processes:
-                            if p.electric_power is not None and p.duration is None:
-                                row_count = (
-                                    area.row_count if area.row_count is not None else 1
-                                )
-
-                                vehicle_count += area.capacity * row_count
-
-                assert (
-                    vehicle_count > 0
-                ), f"The charging area capacity for vehicle type {vehicle_type} should not be 0."
-
-                eflips.globalConstants["depot"]["vehicle_count"][depot_id][
-                    vehicle_type
-                ] = (vehicle_count * 2)
+                vehicle_type_object = (
+                    session.query(VehicleType)
+                    .filter(
+                        VehicleType.id == vehicle_type,
+                        VehicleType.scenario_id == scenario.id,
+                    )
+                    .one()
+                )
+                vehicle_count = len(rotations.get(vehicle_type_object, []))
+
+                if vehicle_count > 0:
+                    eflips.globalConstants["depot"]["vehicle_count"][depot_id][
+                        vehicle_type
+                    ] = (
+                        vehicle_count
+                        * 4  # We multiply by 4 because we repeat the vehicle schedules 4 times
+                    )
+                else:
+                    warnings.warn(
+                        f"There are no rotations assigned to type {vehicle_type_object} in depot {depot_id}"
+                    )
 
     # We  need to put the vehicle type objects into the GlobalConstants
     for vehicle_type in (
@@ -1023,6 +1029,9 @@ 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
 
@@ -1049,23 +1058,16 @@ def add_evaluation_to_database(
                 # handled. It is usually the departure time of the last copy trip in the "early-shifted" copy
                 # schedules and the departure time of the first copy trip in the "late-shifted" copy schedules.
             ) = get_finished_schedules_per_vehicle(
-                dict_of_events, current_vehicle.finished_trips, current_vehicle_db.id
+                dict_of_events,
+                current_vehicle.finished_trips,
+                current_vehicle_db.id,
+                unstable_exp,
+                delay_exp,
             )
 
-            try:
-                assert earliest_time is not None and latest_time is not None
-
-            except AssertionError as e:
-                warnings.warn(
-                    f"Vehicle {current_vehicle_db.id} has only copied trips. The profiles of this vehicle "
-                    f"will not be written into database."
-                )
+            if schedule_current_vehicle is None:
                 continue
 
-            assert (
-                earliest_time < latest_time
-            ), f"Earliest time {earliest_time} is not less than latest time {latest_time}."
-
             list_of_assigned_schedules.extend(schedule_current_vehicle)
 
             generate_vehicle_events(
@@ -1082,16 +1084,6 @@ def add_evaluation_to_database(
 
             add_soc_to_events(dict_of_events, current_vehicle.battery_logs)
 
-            try:
-                assert (not dict_of_events) is False
-            except AssertionError as e:
-                warnings.warn(
-                    f"Vehicle {current_vehicle_db.id} has no valid events. The vehicle will not be written "
-                    f"into database."
-                )
-
-                continue
-
             add_events_into_database(
                 current_vehicle_db,
                 dict_of_events,
@@ -1104,6 +1096,16 @@ 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 len(errors) > 0:
+            raise MultipleErrors(errors)
+
 
 def generate_depot_optimal_size(
     scenario: Union[Scenario, int, Any],
@@ -1112,9 +1114,12 @@ def generate_depot_optimal_size(
     database_url: Optional[str] = None,
     delete_existing_depot: bool = False,
     use_consumption_lut: bool = False,
+    repetition_period: Optional[timedelta] = None,
 ) -> None:
     """
-    Generates an optimal depot layout with the smallest possible size for each depot in the scenario. Line charging areas
+    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: Either a :class:`eflips.model.Scenario` object containing the input data for the simulation. Or
@@ -1125,11 +1130,14 @@ def generate_depot_optimal_size(
     :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 using_consumption_lut: If True, the depot layout will be generated based on the consumption lookup table.
+    :param use_consumption_lut: If True, the depot layout will be generated based on the consumption lookup table.
         If False, constant consumption stored in VehicleType table will be used.
+    :param repetition_period: An optional timedelta object specifying the period of the vehicle schedules. If not
+        specified, a default repetition period will be generated in simulate_scenario(). If the depot layout generated
+        in this function will be used for further simulations, make sure that the repetition period is set to the same
+        value as in the simulation.
 
     :return: None. The depot layout will be added to the database.
-
     """
 
     logger = logging.getLogger(__name__)
@@ -1183,10 +1191,12 @@ def generate_depot_optimal_size(
 
         num_rotations_for_scenario: Dict[Station, int] = {}
 
+        grouped_rotations = group_rotations_by_start_end_stop(scenario.id, session)
+
         for (
             first_last_stop_tup,
             vehicle_type_dict,
-        ) in group_rotations_by_start_end_stop(scenario.id, session).items():
+        ) in grouped_rotations.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.")
@@ -1230,6 +1240,7 @@ def generate_depot_optimal_size(
                     session,
                     standard_block_length,
                     charging_power,
+                    repetition_period,
                 )
 
                 depot_capacities_for_scenario[station] = vt_capacities_for_station
@@ -1239,8 +1250,44 @@ def generate_depot_optimal_size(
 
         outer_savepoint.rollback()
 
+        # Estimation of the number of shunting and cleaning slots
+
         # Create depot using the calculated capacities
         for depot_station, capacities in depot_capacities_for_scenario.items():
+            vehicle_type_rot_dict = grouped_rotations[depot_station, depot_station]
+
+            all_rotations_this_depot = []
+
+            for vehicle_type, rotations in vehicle_type_rot_dict.items():
+                all_rotations_this_depot.extend(rotations)
+
+            # sort the rotations by their start time
+            all_rotations_this_depot.sort(key=lambda r: r.trips[0].departure_time)
+
+            start_time = all_rotations_this_depot[0].trips[0].departure_time
+            end_time = all_rotations_this_depot[-1].trips[-1].arrival_time
+
+            elapsed_time = (end_time - start_time).total_seconds()
+            # make them into a numpy with 30 min resolution
+            import numpy as np
+
+            TIME_RESOLUTION = 30 * 60  # 30 minutes in seconds
+
+            time_range = np.zeros(int(elapsed_time / TIME_RESOLUTION) + 1)
+            # calculate the number of rotations per time slot
+            for rot in all_rotations_this_depot:
+                start_time_index = int(
+                    (rot.trips[0].departure_time - start_time).total_seconds()
+                    // TIME_RESOLUTION
+                )
+                end_time_index = int(
+                    (rot.trips[-1].arrival_time - start_time).total_seconds()
+                    // TIME_RESOLUTION
+                )
+                # interpolate the start and end time to the time range
+
+                time_range[start_time_index : end_time_index + 1] += 1
+
             generate_depot(
                 capacities,
                 depot_station,
@@ -1248,6 +1295,50 @@ def generate_depot_optimal_size(
                 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,
+                num_shunting_slots=int(max(time_range)),
+                num_cleaning_slots=int(max(time_range)),
             )
+
+
+def schedule_duration_days(
+    scenario: Union[Scenario, int, Any], database_url: Optional[str] = None
+) -> timedelta:
+    """
+    This method calculates the duration of a given scenario in days.
+
+    This is the duration
+    between the first departure of the first day, and the last departure on the last day, rounded up to full days.
+
+    Most of the time, this is the "natural" repetition period of the scenario. We are simulating one full period, and
+    this period – continuously repeated – is what happens in reality.
+
+    This method can be used to show the user what the detected repetition period is and to auto-set the repetition
+    period if none is provided.
+
+    :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.
+    :return: a timedelta object representing the duration in days.
+    """
+    with create_session(scenario, database_url) as (session, scenario):
+        first_departure = (
+            session.query(func.min(Trip.departure_time))
+            .filter(Trip.scenario_id == scenario.id)
+            .scalar()
+        )
+        if first_departure is None:
+            raise ValueError("No trips found in the scenario.")
+
+        last_departure = (
+            session.query(func.max(Trip.departure_time))
+            .filter(Trip.scenario_id == scenario.id)
+            .scalar()
+        )
+        if last_departure is None:
+            raise ValueError("No trips found in the scenario.")
+
+        duration = last_departure - first_departure
+        duration_days = ceil(duration.total_seconds() / (24 * 60 * 60))
+
+        return timedelta(days=duration_days)

{eflips_depot-4.13.0 → eflips_depot-4.13.2}/eflips/depot/api/private/depot.py

@@ -3,7 +3,7 @@ import logging
 import math
 from datetime import timedelta
 from enum import Enum, auto
-from typing import Dict, List, Tuple
+from typing import Dict, List, Tuple, Optional
 
 import numpy as np
 import sqlalchemy.orm
@@ -583,12 +583,17 @@ def generate_depot(
     session.add_all(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=100,
+        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)
 
@@ -849,6 +854,7 @@ def depot_smallest_possible_size(
     session: sqlalchemy.orm.session.Session,
     standard_block_length: int = 6,
     charging_power: float = 90,
+    repetition_period: Optional[timedelta] = None,
 ) -> Dict[VehicleType, Dict[AreaType, None | int]]:
     """
     Identifies the smallest (in terms of area footprint) depot that can still fit the required vehicles.
@@ -919,7 +925,12 @@ def depot_smallest_possible_size(
         from eflips.depot.api import SmartChargingStrategy
 
         # Simulate the depot
-        simulate_scenario(scenario, smart_charging_strategy=SmartChargingStrategy.NONE)
+
+        simulate_scenario(
+            scenario,
+            smart_charging_strategy=SmartChargingStrategy.NONE,
+            repetition_period=repetition_period,
+        )
 
         # Find the peak usage of the depot
         peak_occupancies: Dict[VehicleType, Dict[AreaType, int]] = find_peak_usage(

{eflips_depot-4.13.0 → eflips_depot-4.13.2}/eflips/depot/api/private/results_to_database.py

@@ -1,6 +1,7 @@
 import datetime
 import itertools
 import logging
+import warnings
 from datetime import timedelta
 from typing import List, Dict
 
@@ -13,7 +14,11 @@ from eflips.depot import UnstableSimulationException, DelayedTripException
 
 
 def get_finished_schedules_per_vehicle(
-    dict_of_events, list_of_finished_trips: List, db_vehicle_id: int
+    dict_of_events,
+    list_of_finished_trips: List,
+    db_vehicle_id: int,
+    unstable_exp: UnstableSimulationException,
+    delay_exp: DelayedTripException,
 ):
     """
     This function completes the following tasks:
@@ -42,47 +47,62 @@ def get_finished_schedules_per_vehicle(
     :return: A tuple of three elements. The first element is a list of finished schedules of the vehicle. The second and
         third elements are the earliest and latest time of the vehicle's schedules.
     """
-    finished_schedules = []
 
     list_of_finished_trips.sort(key=lambda x: x.atd)
-    earliest_time = None
-    latest_time = None
 
     for i in range(len(list_of_finished_trips)):
-        try:
-            assert list_of_finished_trips[i].atd == list_of_finished_trips[i].std
-        except AssertionError:
-            raise DelayedTripException(
-                f"The trip {list_of_finished_trips[i].ID} is delayed. The simulation doesn't "
-                "support delayed trips for now."
-            )
+        if list_of_finished_trips[i].atd != list_of_finished_trips[i].std:
+            delay_exp.raise_later(list_of_finished_trips[i])
 
-        if list_of_finished_trips[i].is_copy is False:
-            current_trip = list_of_finished_trips[i]
+    non_copy_trips = [trip for trip in list_of_finished_trips if trip.is_copy is False]
 
-            finished_schedules.append((int(current_trip.ID), db_vehicle_id))
-            dict_of_events[current_trip.atd] = {
-                "type": "Trip",
-                "id": int(current_trip.ID),
-            }
-            if i == 0:
-                raise UnstableSimulationException(
-                    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 ."
-                )
+    if len(non_copy_trips) == 0:
+        warnings.warn(
+            f"Vehicle {db_vehicle_id} has only copied trips and will not be stored in the database. "
+            f"This might suggest an unstable simulation result. "
+            f"Repetition of this schedule may require more vehicles."
+        )
 
-            elif i != 0 and i == len(list_of_finished_trips) - 1:
-                # Vehicle's last trip is a non-copy trip
-                if earliest_time is None:
-                    earliest_time = list_of_finished_trips[i - 1].ata
-                latest_time = list_of_finished_trips[i].ata
+        return None, None, None
 
-            else:
-                if list_of_finished_trips[i - 1].is_copy is True:
-                    earliest_time = list_of_finished_trips[i - 1].ata
-                if list_of_finished_trips[i + 1].is_copy is True:
-                    latest_time = list_of_finished_trips[i + 1].atd
+    idx_first_orig_trip = list_of_finished_trips.index(non_copy_trips[0])
+    idx_last_orig_trip = list_of_finished_trips.index(non_copy_trips[-1])
+
+    if idx_first_orig_trip == 0:
+        unstable_exp.raise_later(non_copy_trips[0])
+        earliest_time = non_copy_trips[0].ata
+
+    else:
+        earliest_time = list_of_finished_trips[idx_first_orig_trip - 1].ata
+
+    if idx_last_orig_trip == len(list_of_finished_trips) - 1:
+        # the last trip of this vehicle is a non-copy trip
+        all_processes_current_vehicle = non_copy_trips[-1].vehicle.logger.loggedData[
+            "dwd.active_processes_copy"
+        ]
+        time_stamps = [k for k, v in all_processes_current_vehicle.items()]
+        last_time_stamp = max(time_stamps)
+        if len(all_processes_current_vehicle[last_time_stamp]) == 0:
+            latest_time = last_time_stamp
+        else:
+            current_processes = all_processes_current_vehicle[last_time_stamp]
+
+            latest_time = 0
+            for p in current_processes:
+                latest_time = max((p.starts[0] + p.dur), latest_time)
+
+    else:
+        latest_time = list_of_finished_trips[idx_last_orig_trip + 1].atd
+
+    assert earliest_time <= latest_time
+
+    finished_schedules = []
+    for non_copy_trip in non_copy_trips:
+        finished_schedules.append((int(non_copy_trip.ID), db_vehicle_id))
+        dict_of_events[non_copy_trip.atd] = {
+            "type": "Trip",
+            "id": int(non_copy_trip.ID),
+        }
 
     return finished_schedules, earliest_time, latest_time
 

{eflips_depot-4.13.0 → eflips_depot-4.13.2}/pyproject.toml

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