eflips-depot 4.14.3__tar.gz → 4.15.1__tar.gz

{eflips_depot-4.14.3 → eflips_depot-4.15.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eflips-depot
-Version: 4.14.3
+Version: 4.15.1
 Summary: Depot Simulation for eFLIPS
 License: AGPL-3.0-or-later
 License-File: LICENSE.md
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: eflips (>=0.1.3,<0.2.0)
 Requires-Dist: eflips-model (>=10.0.0,<11.0.0)
-Requires-Dist: eflips-opt (>=0.3.0,<0.4.0)
+Requires-Dist: eflips-opt (>=0.3.6,<0.4.0)
 Requires-Dist: pandas (>=2.2.0,<3.0.0)
 Requires-Dist: scipy (>=1.14.0,<2.0.0)
 Requires-Dist: simpy (>=4.0.1,<5.0.0)

{eflips_depot-4.14.3 → eflips_depot-4.15.1}/eflips/depot/api/__init__.py

@@ -532,6 +532,7 @@ def apply_even_smart_charging(
     scenario: Union[Scenario, int, Any],
     database_url: Optional[str] = None,
     standby_departure_duration: timedelta = timedelta(minutes=5),
+    delete_existing_charging_timeseries: bool = False,
 ) -> None:
     """
     Takes a scenario where depot simulation has been run and applies smart charging to the depot.
@@ -548,6 +549,8 @@ def apply_even_smart_charging(
     :param standby_departure_duration: The duration of the STANDBY_DEPARTURE event. This is the time the vehicle is
         allowed to wait at the depot before it has to leave. The default is 5 minutes.
 
+    :param delete_existing_timeseries: If True, the existing timeseries in the charging events will be deleted.
+
     :return: None. The results are added to the database.
     """
     logger = logging.getLogger(__name__)
@@ -564,6 +567,19 @@ def apply_even_smart_charging(
         raise
 
     with create_session(scenario, database_url) as (session, scenario):
+        if delete_existing_charging_timeseries is False:
+            raise ValueError(
+                "The existing timeseries of charging events needed to be deleted. Set "
+                "delete_existing_charging_timeseries=True to delete them."
+            )
+
+        # Delete existing timeseries in charging events
+        session.query(Event).filter(
+            Event.event_type == EventType.CHARGING_DEPOT,
+            Event.scenario_id == scenario.id,
+        ).update({"timeseries": None}, synchronize_session=False)
+        session.expire_all()
+
         depots = session.query(Depot).filter(Depot.scenario_id == scenario.id).all()
         for depot in depots:
             add_slack_time_to_events_of_depot(

{eflips_depot-4.14.3 → eflips_depot-4.15.1}/eflips/depot/api/private/consumption.py

@@ -286,20 +286,6 @@ def extract_trip_information(
             )
             .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 = (
@@ -307,6 +293,13 @@ def extract_trip_information(
         ).total_seconds() / 3600
         average_speed = total_distance / total_duration  # km/h
 
+        # 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]
+
         temperature = temperature_for_trip(trip_id, session)
 
         payload_mass = passenger_mass * passenger_count
@@ -324,16 +317,46 @@ def extract_trip_information(
         )
         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,
-        )
+        if len(all_consumption_luts) == 1:
+            consumption_lut = all_consumption_luts[0]
+            # Disconnect the consumption LUT from the session to avoid loading the whole table
+
+            del all_consumption_luts
+
+            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()
+        elif len(all_consumption_luts) == 0:
+            warnings.warn(
+                f"No consumption LUT found for vehicle type {trip.rotation.vehicle_type}.",
+                ConsistencyWarning,
+            )
+            # Here, we fill out the condumption information without the LUT and LUT data, but with `consumption_per_km`
+            # set to the vehicle's `consumption` value.
+            assert (
+                VehicleType.consumption is not None
+            ), f"Vehicle type {trip.rotation.vehicle_type} must have a consumption value set if no consumption LUT is available."
+            info = ConsumptionInformation(
+                trip_id=trip.id,
+                average_speed=average_speed,
+                distance=total_distance,
+                consumption_per_km=trip.rotation.vehicle_type.consumption,
+                consumption=trip.rotation.vehicle_type.consumption * total_distance,
+                consumption_lut=None,
+                temperature=temperature,
+                level_of_loading=level_of_loading,
+            )
+        else:
+            raise ValueError(
+                f"Expected exactly one consumption LUT, got {len(all_consumption_luts)}"
+            )
 
-        info.calculate()
     return info
 
 

{eflips_depot-4.14.3 → eflips_depot-4.15.1}/eflips/depot/api/private/depot.py

@@ -204,7 +204,7 @@ def depot_to_template(depot: Depot) -> Dict[str, str | Dict[str, str | int]]:
     list_of_processes = []
 
     # Get dictionary of each area
-    # For line areas, generate an dictionary item for total areas, later it will be split into individual lines
+    # For line areas, generate a dictionary item for total areas, later it will be split into individual lines
     for area in depot.areas:
         area_name = str(area.id)
         template["areas"][area_name] = {
@@ -226,6 +226,17 @@ def depot_to_template(depot: Depot) -> Dict[str, str | Dict[str, str | int]]:
                 "filter_names": ["vehicle_type"],
                 "vehicle_types": [str(area.vehicle_type_id)],
             }
+            for processes_in_area in area.processes:
+                if process_type(processes_in_area) == ProcessType.CHARGING:
+                    # Add the charging process for this vehicle type
+                    template["areas"][area_name]["available_processes"].append(
+                        str(processes_in_area.id) + str(area.vehicle_type_id)
+                    )
+                    # Delete the original charging process
+                    template["areas"][area_name]["available_processes"].remove(
+                        str(processes_in_area.id)
+                    )
+
         else:
             # If the vehicle type id is not set, the area is for all vehicle types
             scenario = depot.scenario
@@ -236,6 +247,19 @@ def depot_to_template(depot: Depot) -> Dict[str, str | Dict[str, str | int]]:
                 "vehicle_types": all_vehicle_type_ids,
             }
 
+            # if there are any charging areas, all a unique charging process for each vehicle type
+            for processes_in_area in area.processes:
+                if process_type(processes_in_area) == ProcessType.CHARGING:
+                    # Add the charging process for this vehicle type
+                    for vt in scenario.vehicle_types:
+                        template["areas"][area_name]["available_processes"].append(
+                            str(processes_in_area.id) + str(vt.id)
+                        )
+                    # Delete the original charging process
+                    template["areas"][area_name]["available_processes"].remove(
+                        str(processes_in_area.id)
+                    )
+
         for process in area.processes:
             # Add process into process list
             list_of_processes.append(
@@ -285,7 +309,7 @@ def depot_to_template(depot: Depot) -> Dict[str, str | Dict[str, str | int]]:
     for name in line_areas_to_delete:
         del area_template[name]
 
-    # Fill in the dictionary of processess
+    # Fill in the dictionary of processes
     for process in list_of_processes:
         process_name = str(process.id)
         # Shared template for all processes
@@ -358,8 +382,42 @@ def depot_to_template(depot: Depot) -> Dict[str, str | Dict[str, str | int]]:
                     ] = list_of_breaks_in_seconds
 
             case ProcessType.CHARGING:
-                template["processes"][process_name]["typename"] = "Charge"
-                del template["processes"][process_name]["dur"]
+                all_vehicle_types = depot.scenario.vehicle_types
+
+                for vt in all_vehicle_types:
+                    charging_curve = vt.charging_curve
+                    template["processes"][process_name + str(vt.id)] = template[
+                        "processes"
+                    ][process_name].copy()
+                    template["processes"][process_name + str(vt.id)][
+                        "typename"
+                    ] = "ChargeEquationSteps"
+                    template["processes"][process_name + str(vt.id)][
+                        "vehicle_filter"
+                    ] = {
+                        "filter_names": ["vehicle_type"],
+                        "vehicle_types": [str(vt.id)],
+                    }
+
+                    template["processes"][process_name + str(vt.id)][
+                        "peq_name"
+                    ] = "charging_curve_power"
+                    template["processes"][process_name + str(vt.id)]["peq_params"] = {
+                        "soc": [soc_power_pair[0] for soc_power_pair in charging_curve],
+                        "power": [
+                            soc_power_pair[1] for soc_power_pair in charging_curve
+                        ],
+                    }
+
+                    del template["processes"][process_name + str(vt.id)]["dur"]
+
+                # delete the original process
+                del template["processes"][process_name]
+
+                # The original one
+                # template["processes"][process_name]["typename"] = "Charge"
+
+                # del template["processes"][process_name]["dur"]
 
             case ProcessType.STANDBY | ProcessType.STANDBY_DEPARTURE:
                 template["processes"][process_name]["typename"] = "Standby"

{eflips_depot-4.14.3 → eflips_depot-4.15.1}/eflips/depot/api/private/results_to_database.py

@@ -225,8 +225,6 @@ def generate_vehicle_events(
                 "is_waiting": True,
             }
 
-    # Create a list of battery log in order of time asc. Convenient for looking up corresponding soc
-
     for time_stamp, process_log in current_vehicle.logger.loggedData[
         "dwd.active_processes_copy"
     ].items():
@@ -276,13 +274,18 @@ def generate_vehicle_events(
                                     )
                                     start_this_event = dict_of_events[time_stamp]["end"]
                                 else:
-                                    for other_process in process_log:
-                                        if (
-                                            other_process.ID != process.ID
-                                            and other_process.dur > 0
-                                        ):
-                                            start_this_event = other_process.ends[0]
-                                            break
+                                    if len(process_log) > 1:
+                                        # This is for the case where the charging and standby_departure happen in the same area, and the standby_departure is the last process.
+                                        for other_process in process_log:
+                                            if (
+                                                other_process.ID != process.ID
+                                                and other_process.dur > 0
+                                            ):
+                                                start_this_event = other_process.ends[0]
+                                                break
+                                    else:
+                                        # This is for the case where only standby_departure happens in the last area.
+                                        start_this_event = time_stamp
 
                                 assert (
                                     start_this_event is not None
@@ -395,7 +398,7 @@ def add_soc_to_events(dict_of_events, battery_log) -> None:
     """
     battery_log_list = []
     for log in battery_log:
-        battery_log_list.append((log.t, log.energy / log.energy_real))
+        battery_log_list.append((log.t, round(log.energy / log.energy_real, 4)))
 
     time_keys = sorted(dict_of_events.keys())
 
@@ -408,15 +411,42 @@ def add_soc_to_events(dict_of_events, battery_log) -> None:
         start_time = time_keys[i]
         process_dict = dict_of_events[time_keys[i]]
 
-        if process_dict["type"] != "Trip":
-            soc_start = np.interp(start_time, battery_log_times, battery_log_socs)
-            process_dict["soc_start"] = min(float(soc_start), 1.0)
-            soc_end = np.interp(
-                process_dict["end"], battery_log_times, battery_log_socs
-            )
-            process_dict["soc_end"] = min(float(soc_end), 1.0)
-        else:
-            continue
+        match process_dict["type"]:
+            case "Charge" | "ChargeSteps" | "ChargeEquationSteps":
+                event_start = start_time
+                event_end = process_dict["end"]
+                start_time_index = battery_log_times.index(event_start)
+                end_time_index = battery_log_times.index(event_end)
+                time_series = {
+                    "time": battery_log_times[start_time_index:end_time_index],
+                    "soc": battery_log_socs[start_time_index:end_time_index],
+                }
+
+                # if there are repeated timestamps, we need to remove them
+                unique_indices = np.unique(
+                    time_series["time"], return_index=True, return_inverse=False
+                )[1]
+                time_series["time"] = [
+                    time_series["time"][index] for index in unique_indices
+                ]
+                time_series["soc"] = [
+                    time_series["soc"][index] for index in unique_indices
+                ]
+                process_dict["timeseries"] = time_series
+                process_dict["soc_start"] = battery_log_socs[start_time_index]
+                process_dict["soc_end"] = battery_log_socs[end_time_index]
+
+            case "Serve" | "Standby":
+                soc_start = np.interp(start_time, battery_log_times, battery_log_socs)
+                process_dict["soc_start"] = min(float(soc_start), 1.0)
+                soc_end = np.interp(
+                    process_dict["end"], battery_log_times, battery_log_socs
+                )
+                process_dict["soc_end"] = min(float(soc_end), 1.0)
+            case "Trip":
+                continue
+            case _:
+                raise NotImplementedError
 
 
 def add_events_into_database(
@@ -446,7 +476,7 @@ def add_events_into_database(
         match process_dict["type"]:
             case "Serve":
                 event_type = EventType.SERVICE
-            case "Charge":
+            case "Charge" | "ChargeSteps" | "ChargeEquationSteps":  # TODO that might be problematic
                 event_type = EventType.CHARGING_DEPOT
             case "Standby":
                 if (
@@ -488,6 +518,20 @@ def add_events_into_database(
             capacity_per_line = int(current_area.capacity / current_area.row_count)
             process_dict["slot"] = capacity_per_line * row + process_dict["slot"] - 1
 
+        timeseries = {}
+        if "timeseries" in process_dict.keys():
+            # Convert "time" in timeseries to timedelta
+            timeseries["time"] = [
+                (timedelta(seconds=t) + simulation_start_time).isoformat()
+                for t in process_dict["timeseries"]["time"]
+            ]
+            timeseries["soc"] = process_dict["timeseries"]["soc"]
+
+            assert all(
+                timeseries["soc"][i] <= timeseries["soc"][i + 1]
+                for i in range(len(timeseries["soc"]) - 1)
+            ), "SOC values in the timeseries should be non-decreasing."
+
         current_event = Event(
             scenario=scenario,
             vehicle_type_id=db_vehicle.vehicle_type_id,
@@ -507,7 +551,7 @@ def add_events_into_database(
             # then this is not an event with soc change
             event_type=event_type,
             description=process_dict["id"] if "id" in process_dict.keys() else None,
-            timeseries=None,
+            timeseries=timeseries if "timeseries" in process_dict.keys() else None,
         )
 
         session.add(current_event)

{eflips_depot-4.14.3 → eflips_depot-4.15.1}/eflips/depot/api/private/util.py

@@ -1,6 +1,7 @@
 """This module contains miscellaneous utility functions for the eflips-depot API."""
 import logging
 import os
+import warnings
 from contextlib import contextmanager
 from dataclasses import dataclass
 from datetime import timedelta, datetime
@@ -17,9 +18,11 @@ from eflips.model import (
     Trip,
     Depot,
     Temperatures,
+    ConsistencyWarning,
 )
 from eflips.model import create_engine
 from sqlalchemy import inspect
+from sqlalchemy.exc import NoResultFound
 from sqlalchemy.orm import Session
 
 from eflips.depot import SimpleTrip, Timetable as EflipsTimeTable
@@ -204,7 +207,9 @@ def check_depot_validity(depot: Depot) -> None:
 
 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.
+    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
@@ -212,11 +217,18 @@ def temperature_for_trip(trip_id: int, session: Session) -> float:
     """
 
     trip = session.query(Trip).filter(Trip.id == trip_id).one()
-    temperatures = (
-        session.query(Temperatures)
-        .filter(Temperatures.scenario_id == trip.scenario_id)
-        .one()
-    )
+    try:
+        temperatures = (
+            session.query(Temperatures)
+            .filter(Temperatures.scenario_id == trip.scenario_id)
+            .one()
+        )
+    except NoResultFound:
+        warnings.warn(
+            f"No temperatures found for scenario {trip.scenario_id}.",
+            ConsistencyWarning,
+        )
+        return None
 
     # Find the mid-point of the trip
     mid_time = trip.departure_time + (trip.arrival_time - trip.departure_time) / 2

{eflips_depot-4.14.3 → eflips_depot-4.15.1}/eflips/depot/depot.py

@@ -1360,7 +1360,9 @@ class DepotControl:
             for procID in area.available_processes
             if self.depot.processes[procID]["type"].request_immediately
             and (
+                # TODO: Simplify this condition
                 self.depot.processes[procID]["kwargs"]["ismandatory"]
+                and self.depot.processes[procID]["kwargs"]["vehicle_filter"](vehicle)
                 or not self.depot.processes[procID]["kwargs"]["ismandatory"]
                 and self.depot.processes[procID]["kwargs"]["vehicle_filter"](vehicle)
             )

{eflips_depot-4.14.3 → eflips_depot-4.15.1}/eflips/depot/processes.py

@@ -6,6 +6,7 @@ from abc import ABC, abstractmethod
 from enum import auto, Enum
 from warnings import warn
 
+import numpy as np
 import simpy
 from eflips.helperFunctions import flexprint
 from eflips.settings import globalConstants
@@ -672,7 +673,7 @@ class ChargeAbstract(VehicleProcess, ABC):
         cancellable_for_dispatch=False,
         efficiency=1,
         *args,
-        **kwargs
+        **kwargs,
     ):
         if required_resources is not None:
             raise ValueError(
@@ -1428,6 +1429,25 @@ def exponential_power(vehicle, charging_interface, peq_params, *args, **kwargs):
         )
 
 
+def charging_curve_power(vehicle, charging_interface, peq_params):
+    """
+    Return power in kW for given peq_params in the format of dict[flaot, float]
+    :param vehicle: SimpleVehicle
+    :param charging_interface: DepotChargingInterface storing maximum power from charger
+    :param peq_params: A dictionary with "soc" storing soc turning points and "power" for corresponding charging power
+    :return: charging power in float for given SimpleVehicle
+    """
+
+    current_soc = vehicle.battery.soc
+    p_max = charging_interface.max_power
+
+    current_power = min(
+        p_max, np.interp(current_soc, peq_params["soc"], peq_params["power"])
+    )
+
+    return float(current_power)
+
+
 class Standby(VehicleProcess):
     """Process of mandatory waiting such as standby times."""
 

{eflips_depot-4.14.3 → eflips_depot-4.15.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "eflips-depot"
-version = "4.14.3"
+version = "4.15.1"
 description = "Depot Simulation for eFLIPS"
 authors = ["Enrico Lauth <enrico.lauth@tu-berlin.de>",
     "Ludger Heide <ludger.heide@tu-berlin.de",
@@ -23,7 +23,7 @@ pandas = "^2.2.0"
 xlrd = "<=1.2.0"
 scipy = "^1.14.0"
 eflips-model = "^10.0.0"
-eflips-opt = "^0.3.0"
+eflips-opt = "^0.3.6"
 
 
 [tool.pytest.ini_options]