eflips-depot 3.0.2__tar.gz → 3.0.4__tar.gz

{eflips_depot-3.0.2 → eflips_depot-3.0.4}/PKG-INFO

@@ -1,22 +1,24 @@
 Metadata-Version: 2.1
 Name: eflips-depot
-Version: 3.0.2
+Version: 3.0.4
 Summary: Depot Simulation for eFLIPS
-License: AGPLv3
+Home-page: https://github.com/mpm-tu-berlin/eflips-depot
+License: AGPL-3.0-or-later
 Author: Enrico Lauth
 Author-email: enrico.lauth@tu-berlin.de
 Requires-Python: >=3.10,<4.0
-Classifier: License :: Other/Proprietary License
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: eflips (>=0.1.1,<0.2.0)
-Requires-Dist: eflips-model (>=3.1.0,<4.0.0)
+Requires-Dist: eflips (>=0.1.3,<0.2.0)
+Requires-Dist: eflips-model (>=3.2.0,<4.0.0)
 Requires-Dist: pandas (>=2.1.4,<3.0.0)
 Requires-Dist: simpy (>=4.0.1,<5.0.0)
 Requires-Dist: xlrd (<=1.2.0)
 Requires-Dist: xlsxwriter (>=3.1.9,<4.0.0)
+Project-URL: Repository, https://github.com/mpm-tu-berlin/eflips-depot
 Description-Content-Type: text/markdown
 
 [![Tests](https://github.com/mpm-tu-berlin/eflips-depot/actions/workflows/postgres_eflips_depot.yml/badge.svg)](https://github.com/mpm-tu-berlin/eflips-depot/actions/workflows/postgres_eflips_depot.yml)

{eflips_depot-3.0.2 → eflips_depot-3.0.4}/eflips/depot/api/__init__.py

@@ -26,6 +26,7 @@ The following steps are recommended for using the API:
 """
 import copy
 import os
+import warnings
 from datetime import timedelta
 from math import ceil
 from typing import Any, Dict, Optional, Union
@@ -41,6 +42,8 @@ from eflips.model import (
     Scenario,
     Trip,
     Vehicle,
+    Process,
+    AssocAreaProcess,
 )
 from sqlalchemy.orm import Session
 from sqlalchemy.sql import select
@@ -303,7 +306,7 @@ def generate_depot_layout(
             max_occupancies: Dict[eflips.model.VehicleType, int] = {}
             max_clean_occupancies: Dict[eflips.model.VehicleType, int] = {}
             for vehicle_type, rotations in vehicle_type_dict.items():
-                # Slightly convoulted vehicle summation
+                # Slightly convoluted vehicle summation
                 start_time = min(
                     [rotation.trips[0].departure_time for rotation in rotations]
                 ).timestamp()
@@ -529,13 +532,15 @@ def init_simulation(
                 depot_id
             ] = vehicle_count_dict[depot_id]
         else:
-            # Calculate it from the size of the areas, with a 2x margin
+            # Calculate it from the size of the areas (except the area for the first standby process, which is already
+            # really large), with a 2x margin
             for vehicle_type in vehicle_types_for_depot:
                 vehicle_count = sum(
                     [
                         area.capacity
                         for area in depot.areas
                         if area.vehicle_type_id == int(vehicle_type)
+                        and depot.default_plan.processes[0] not in area.processes
                     ]
                 )
                 eflips.globalConstants["depot"]["vehicle_count"][depot_id][
@@ -660,14 +665,10 @@ def add_evaluation_to_database(
 
         list_of_vehicles = []
 
-        list_of_events = []
-
         list_of_assigned_schedules = []
 
         # Read results from depot_evaluation categorized by vehicle
         for current_vehicle in depot_evaluation.vehicle_generator.items:
-            list_of_events_per_vehicle = []
-
             vehicle_type_id = int(current_vehicle.vehicle_type.ID)
 
             # Create a Vehicle object for database
@@ -684,6 +685,7 @@ def add_evaluation_to_database(
 
             dict_of_events = {}
 
+            # Generate process log for each schedule
             for finished_trip in current_vehicle.finished_trips:
                 dict_of_events[finished_trip.atd] = {
                     "type": "trip",
@@ -710,6 +712,57 @@ def add_evaluation_to_database(
             waiting_log = current_vehicle.logger.loggedData["area_waiting_time"]
             battery_log = current_vehicle.battery_logs
 
+            # Create standby events according to waiting_log
+            waiting_log_timekeys = sorted(waiting_log.keys())
+
+            for idx in range(len(waiting_log_timekeys)):
+                end_time = waiting_log_timekeys[idx]
+                waiting_info = waiting_log[end_time]
+
+                if waiting_info["waiting_time"] == 0:
+                    continue
+
+                # Vehicle is waiting in the last area in waiting_log and expecting to enter the current area
+                expected_area = waiting_info["area"]
+                # Find the area for standby arrival event
+
+                waiting_area_id = (
+                    session.query(Area.id)
+                    .join(AssocAreaProcess, AssocAreaProcess.area_id == Area.id)
+                    .join(Process, Process.id == AssocAreaProcess.process_id)
+                    .filter(
+                        Process.dispatchable == False,
+                        Process.duration.is_(None),
+                        Process.electric_power.is_(None),
+                        Area.vehicle_type_id == int(current_vehicle.vehicle_type.ID),
+                        Area.scenario_id == scenario.id,
+                    )
+                    .one()[0]
+                )
+
+                # Make sure the vehicle is waiting at an area with enough capacity
+
+                current_slot = slot_log[waiting_log_timekeys[idx - 1]]
+
+                start_time = end_time - waiting_info["waiting_time"]
+
+                warnings.warn(
+                    f"Vehicle {current_vehicle.ID} is waiting at {waiting_area_id} because area {expected_area} is full."
+                )
+
+                dict_of_events[start_time] = {
+                    "type": "Standby",
+                    "end": end_time,
+                    "area": waiting_area_id,
+                    "slot": current_slot,
+                    "is_area_sink": False,
+                }
+
+            # Create a list of battery log in order of time asc. Convenient for looking up corresponding soc
+            battery_log_list = []
+            for log in battery_log:
+                battery_log_list.append((log.t, log.energy / log.energy_real))
+
             for start_time, process_log in current_vehicle.logger.loggedData[
                 "dwd.active_processes_copy"
             ].items():
@@ -843,11 +896,11 @@ def add_evaluation_to_database(
                                     f"Invalid process status {process.status} for process {process.ID}."
                                 )
 
-            time_keys = sorted(dict_of_events.keys(), reverse=True)
-            if len(time_keys) != 0:
+            reversed_time_keys = sorted(dict_of_events.keys(), reverse=True)
+            if len(reversed_time_keys) != 0:
                 # Generating valid event-list
                 is_copy = True
-                for start_time in time_keys:
+                for start_time in reversed_time_keys:
                     process_dict = dict_of_events[start_time]
                     if process_dict["type"] == "trip":
                         is_copy = process_dict["is_copy"]
@@ -875,17 +928,31 @@ def add_evaluation_to_database(
                             # End time of 0-duration processes are start time of the next process
 
                             if "end" not in process_dict:
-                                end_time = time_keys[time_keys.index(start_time) - 1]
+                                # End time will be the one time key "later"
+                                end_time = reversed_time_keys[
+                                    reversed_time_keys.index(start_time) - 1
+                                ]
                                 process_dict["end"] = end_time
 
                             # Get soc
                             soc_start = None
                             soc_end = None
-                            for log in battery_log:
-                                if log.t == start_time:
-                                    soc_start = log.energy / log.energy_real
-                                if log.t == process_dict["end"]:
-                                    soc_end = log.energy / log.energy_real
+
+                            for i in range(len(battery_log_list)):
+                                log = battery_log_list[i]
+
+                                if log[0] == start_time:
+                                    soc_start = log[1]
+                                if log[0] == process_dict["end"]:
+                                    soc_end = log[1]
+                                if log[0] < start_time < battery_log_list[i + 1][0]:
+                                    soc_start = log[1]
+                                if (
+                                    log[0]
+                                    < process_dict["end"]
+                                    < battery_log_list[i + 1][0]
+                                ):
+                                    soc_end = log[1]
 
                             current_event = Event(
                                 scenario=scenario,
@@ -911,18 +978,15 @@ def add_evaluation_to_database(
                                 timeseries=None,
                             )
                             session.add(current_event)
-                            list_of_events_per_vehicle.append(current_event)
-
-                list_of_events.extend(list_of_events_per_vehicle)
 
                 # For non-copy schedules with no predecessor events, adding a dummy standby-departure
                 if (
-                    dict_of_events[time_keys[-1]]["type"] == "trip"
-                    and dict_of_events[time_keys[-1]]["is_copy"] is False
+                    dict_of_events[reversed_time_keys[-1]]["type"] == "trip"
+                    and dict_of_events[reversed_time_keys[-1]]["is_copy"] is False
                 ):
-                    standby_start = time_keys[-1] - 1
-                    standby_end = time_keys[-1]
-                    rotation_id = str(dict_of_events[time_keys[-1]]["id"])
+                    standby_start = reversed_time_keys[-1] - 1
+                    standby_end = reversed_time_keys[-1]
+                    rotation_id = str(dict_of_events[reversed_time_keys[-1]]["id"])
                     area = (
                         session.query(Area)
                         .filter(Area.vehicle_type_id == vehicle_type_id)
@@ -961,49 +1025,15 @@ def add_evaluation_to_database(
                         timeseries=None,
                     )
 
-                    list_of_events.append(standby_event)
-
-        new_old_vehicle = {}
-        matched_vehicle_id = 0
-        for schedule_id, vehicle_id in list_of_assigned_schedules:
-            if vehicle_id != matched_vehicle_id:
-                matched_vehicle_id = vehicle_id
-                # Get rotation from db with id
-                rotation_q = session.query(Rotation).filter(Rotation.id == schedule_id)
-                # Match old and new vehicle id
-                old_vehicle_id = rotation_q.one().vehicle_id
-                new_old_vehicle[vehicle_id] = old_vehicle_id
+                    session.add(standby_event)
 
         # New rotation assignment
-
         for schedule_id, vehicle_id in list_of_assigned_schedules:
             # Get corresponding old vehicle id
-            old_vehicle_id = new_old_vehicle[vehicle_id]
             session.query(Rotation).filter(Rotation.id == schedule_id).update(
-                {"vehicle_id": old_vehicle_id}, synchronize_session="auto"
+                {"vehicle_id": vehicle_id}, synchronize_session="auto"
             )
 
-        # Delete all non-depot events
-        session.query(Event).filter(
-            Event.scenario == scenario,
-            Event.trip_id.isnot(None) | Event.station_id.isnot(None),
-        ).delete()
-
-        session.flush()
-
-        # Update depot events with old vehicle id
-        for new_vehicle_id, old_vehicle_id in new_old_vehicle.items():
-            session.query(Event).filter(
-                Event.scenario == scenario,
-                Event.vehicle_id == new_vehicle_id,
-            ).update({"vehicle_id": old_vehicle_id}, synchronize_session="auto")
-
-            session.query(Vehicle).filter(
-                Vehicle.id == new_vehicle_id,
-            ).delete(synchronize_session="auto")
-
-            session.flush()
-
         # Delete all non-depot events
         session.query(Event).filter(
             Event.scenario == scenario,
@@ -1013,7 +1043,6 @@ def add_evaluation_to_database(
         session.flush()
 
         # Delete all vehicles without rotations
-
         vehicle_assigned_sq = (
             session.query(Rotation.vehicle_id)
             .filter(Rotation.scenario == scenario)

{eflips_depot-3.0.2 → eflips_depot-3.0.4}/eflips/depot/api/private/depot.py

@@ -302,10 +302,13 @@ def create_simple_depot(
     It has one area for each vehicle type and a charging process for each
     area. Also an arrival area for each vehicle type.
 
-    :param scenario:
-    :param station:
-    :param vehicle_type_dict:
-    :param session:
+    :param scenario: The scenario to be simulated
+    :param station: The station where the depot is located
+    :param charging_capacities: A dictionary of vehicle types and the number of vehicles that can be charged at the same time
+    :param cleaning_capacities: A dictionary of vehicle types and the number of vehicles that can be cleaned at the same time
+    :param charging_power: The power of the charging process
+    :param cleaning_duration: The duration of the cleaning process
+    :param session: An SQLAlchemy session object to the database
     :return: Nothing. Depots are created in the database.
     """
 
@@ -354,19 +357,8 @@ def create_simple_depot(
 
     for vehicle_type in charging_capacities.keys():
         charging_count = charging_capacities[vehicle_type]
-        # Add a safety margin of 20% to the parking capacity
-        charging_count = int(ceil(charging_count * 1.2))
-
-        # Create stand by arrival area
-        arrival_area = Area(
-            scenario=scenario,
-            name=f"Arrival for {vehicle_type.name_short}",
-            depot=depot,
-            area_type=AreaType.DIRECT_ONESIDE,
-            capacity=charging_count,
-        )
-        session.add(arrival_area)
-        arrival_area.vehicle_type = vehicle_type
+        # Add a safety margin of 100% to the parking capacity
+        charging_count = int(ceil(charging_count * 2))
 
         # Create charging area
         charging_area = Area(
@@ -381,8 +373,8 @@ def create_simple_depot(
 
         # Create cleaning area
         cleaning_count = cleaning_capacities[vehicle_type]
-        # Add a safety margin of 20% to the parking capacity
-        cleaning_count = int(ceil(cleaning_count * 1.2))
+        # Add a safety margin of 100% to the parking capacity
+        cleaning_count = int(ceil(cleaning_count * 2))
 
         cleaning_area = Area(
             scenario=scenario,
@@ -394,6 +386,18 @@ def create_simple_depot(
         session.add(cleaning_area)
         cleaning_area.vehicle_type = vehicle_type
 
+        # Create stand by arrival area
+        arrival_area = Area(
+            scenario=scenario,
+            name=f"Arrival for {vehicle_type.name_short}",
+            depot=depot,
+            area_type=AreaType.DIRECT_ONESIDE,
+            capacity=(charging_count + cleaning_count)
+            * 2,  # SHould be huge, not all of it will be used
+        )
+        session.add(arrival_area)
+        arrival_area.vehicle_type = vehicle_type
+
         arrival_area.processes.append(standby_arrival)
         cleaning_area.processes.append(clean)
         charging_area.processes.append(charging)

{eflips_depot-3.0.2 → eflips_depot-3.0.4}/eflips/depot/filters.py

@@ -1,4 +1,6 @@
 # -*- coding: utf-8 -*-
+import warnings
+
 import eflips
 from eflips.settings import globalConstants
 from eflips.helperFunctions import flexprint
@@ -248,6 +250,18 @@ class VehicleFilter:
                 required_energy = (
                     self.trip.start_soc - self.trip.end_soc
                 ) * vehicle.battery.energy_real
+
+                # If the vehicle is fully charged and its fully charged energy is still lower than the required energy,
+                # dispatch anyway and warn the user
+                if (
+                    abs(vehicle.battery.soc - 1) < 1e-6
+                    and vehicle.battery.energy_real < required_energy
+                ):
+                    warnings.warn(
+                        f"Vehicle {vehicle.ID} is fully charged but the required energy for the trip is higher than the fully charged energy. Dispatching anyway."
+                    )
+                    return True
+
                 result = required_energy <= vehicle.battery.energy_remaining
 
         else:

{eflips_depot-3.0.2 → eflips_depot-3.0.4}/pyproject.toml

@@ -1,20 +1,22 @@
 [tool.poetry]
 name = "eflips-depot"
-version = "3.0.2"
+version = "3.0.4"
 description = "Depot Simulation for eFLIPS"
 authors = ["Enrico Lauth <enrico.lauth@tu-berlin.de>",
     "Ludger Heide <ludger.heide@tu-berlin.de",
     "Shuyao Guo <shuyao.guo@tu-berlin.de"]
-license = "AGPLv3"
+license = "AGPL-3.0-or-later"
 readme = "README.md"
+homepage = "https://github.com/mpm-tu-berlin/eflips-depot"
+repository = "https://github.com/mpm-tu-berlin/eflips-depot"
 packages = [{ include = "eflips/depot" }]
 
 [tool.poetry.dependencies]
 python = "^3.10"
 simpy = "^4.0.1"
-eflips-model = "^3.1.0"
+eflips-model = "^3.2.0"
 # Legacy dependencies, which are still needed until we refactor the code
-eflips = "^0.1.1"
+eflips = "^0.1.3"
 xlsxwriter = "^3.1.9"
 pandas = "^2.1.4"
 xlrd = "<=1.2.0"