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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eflips-depot
-Version: 4.14.3
+Version: 4.15.9
 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)
@@ -131,5 +131,5 @@ This project is licensed under the AGPLv3 license - see the [LICENSE](LICENSE.md
 
 ## Funding Notice
 
-This code was developed as part of the project [eBus2030+]([https://www.eflip.de/](https://www.now-gmbh.de/projektfinder/e-bus-2030/)) funded by the Federal German Ministry for Digital and Transport (BMDV) under grant number 03EMF0402.
+This code was developed as part of the project [eBus2030+](https://www.now-gmbh.de/projektfinder/e-bus-2030/) funded by the Federal German Ministry for Digital and Transport (BMDV) under grant number 03EMF0402.
 

{eflips_depot-4.14.3 → eflips_depot-4.15.9}/README.md

@@ -104,4 +104,4 @@ This project is licensed under the AGPLv3 license - see the [LICENSE](LICENSE.md
 
 ## Funding Notice
 
-This code was developed as part of the project [eBus2030+]([https://www.eflip.de/](https://www.now-gmbh.de/projektfinder/e-bus-2030/)) funded by the Federal German Ministry for Digital and Transport (BMDV) under grant number 03EMF0402.
+This code was developed as part of the project [eBus2030+](https://www.now-gmbh.de/projektfinder/e-bus-2030/) funded by the Federal German Ministry for Digital and Transport (BMDV) under grant number 03EMF0402.

{eflips_depot-4.14.3 → eflips_depot-4.15.9}/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(
@@ -669,7 +685,9 @@ def simulate_scenario(
             case SmartChargingStrategy.NONE:
                 pass
             case SmartChargingStrategy.EVEN:
-                apply_even_smart_charging(scenario, database_url)
+                apply_even_smart_charging(
+                    scenario, database_url, delete_existing_charging_timeseries=True
+                )
             case SmartChargingStrategy.MIN_PRICE:
                 raise NotImplementedError("MIN_PRICE strategy is not implemented yet.")
             case _:

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

@@ -3,7 +3,7 @@ import warnings
 from dataclasses import dataclass
 from datetime import timedelta, datetime
 from math import ceil
-from typing import Tuple, List
+from typing import Tuple, List, Optional
 from zoneinfo import ZoneInfo
 
 import numpy as np
@@ -88,11 +88,13 @@ class ConsumptionInformation:
     """
 
     trip_id: int
-    consumption_lut: ConsumptionLut | None  # the LUT for the vehicle class
+    consumption_lut: Optional[ConsumptionLut]  # the LUT for the vehicle class
     average_speed: float  # the average speed of the trip in km/h
     distance: float  # the distance of the trip in km
-    temperature: float  # The ambient temperature in °C
-    level_of_loading: float
+    temperature: Optional[float]  # The ambient temperature in °C
+    level_of_loading: Optional[
+        float
+    ]  # The level of loading of the vehicle as a fraction of its maximum payload
     incline: float = 0.0  # The incline of the trip in 0.0-1.0
     consumption: float = None  # The consumption of the trip in kWh
     consumption_per_km: float = None  # The consumption per km in kWh
@@ -286,54 +288,78 @@ def extract_trip_information(
             )
             .one()
         )
+
+        total_distance = trip.route.distance / 1000  # km
+        total_duration = (
+            trip.arrival_time - trip.departure_time
+        ).total_seconds() / 3600
+        average_speed = total_distance / total_duration  # km/h
+
         # 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
+        temperature = temperature_for_trip(trip_id, session)
 
-        total_distance = trip.route.distance / 1000  # km
-        total_duration = (
-            trip.arrival_time - trip.departure_time
-        ).total_seconds() / 3600
-        average_speed = total_distance / total_duration  # km/h
+        if len(all_consumption_luts) == 1:
+            payload_mass = passenger_mass * passenger_count
+            assert (
+                trip.rotation.vehicle_type.allowed_mass is not None
+            ), f"allowed_mass of vehicle {trip.rotation.vehicle_type} must be set"
 
-        temperature = temperature_for_trip(trip_id, session)
+            assert (
+                trip.rotation.vehicle_type.empty_mass is not None
+            ), f"empty_mass of vehicle {trip.rotation.vehicle_type} must be set"
 
-        payload_mass = passenger_mass * passenger_count
-        assert (
-            trip.rotation.vehicle_type.allowed_mass is not None
-        ), f"allowed_mass of vehicle {trip.rotation.vehicle_type} must be set"
+            full_payload = (
+                trip.rotation.vehicle_type.allowed_mass
+                - trip.rotation.vehicle_type.empty_mass
+            )
+            level_of_loading = payload_mass / full_payload
 
-        assert (
-            trip.rotation.vehicle_type.empty_mass is not None
-        ), f"empty_mass of vehicle {trip.rotation.vehicle_type} must be set"
+            consumption_lut = all_consumption_luts[0]
+            # Disconnect the consumption LUT from the session to avoid loading the whole table
 
-        full_payload = (
-            trip.rotation.vehicle_type.allowed_mass
-            - trip.rotation.vehicle_type.empty_mass
-        )
-        level_of_loading = payload_mass / full_payload
-
-        info = ConsumptionInformation(
-            trip_id=trip.id,
-            consumption_lut=consumption_lut,
-            average_speed=average_speed,
-            distance=total_distance,
-            temperature=temperature,
-            level_of_loading=level_of_loading,
-        )
+            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.
+            if trip.rotation.vehicle_type.consumption is None:
+                raise ValueError(
+                    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=None,
+            )
+        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.9}/eflips/depot/api/private/depot.py

@@ -126,20 +126,27 @@ class DepotConfigurationWish:
         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
+            assert (
+                self.default_power is not None
+            ), "default_power must be provided if auto_generate is True"
+            assert (
+                self.standard_block_length is not None
+            ), "standard_block_length must be provided if auto_generate is True"
+
+            assert (
+                self.cleaning_slots is None
+            ), "cleaning_slots cannot be provided if auto_generate is True"
+            assert (
+                self.cleaning_duration is None
+            ), "cleaning_duration cannot be provided if auto_generate is True"
+            assert (
+                self.shunting_slots is None
+            ), "shunting_slots cannot be provided if auto_generate is True"
+            assert (
+                self.shunting_duration is None
+            ), "shunting_duration cannot be provided if auto_generate is True"
+
+            assert areas is None, "areas cannot be provided if auto_generate is True"
 
 
 def delete_depots(scenario: Scenario, session: Session) -> None:
@@ -204,7 +211,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 +233,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) + "vt" + 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 +254,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) + "vt" + 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 +316,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 +389,43 @@ 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
+
+                    charging_process_name = process_name + "vt" + str(vt.id)
+                    template["processes"][charging_process_name] = template[
+                        "processes"
+                    ][process_name].copy()
+                    template["processes"][charging_process_name][
+                        "typename"
+                    ] = "ChargeEquationSteps"
+                    template["processes"][charging_process_name]["vehicle_filter"] = {
+                        "filter_names": ["vehicle_type"],
+                        "vehicle_types": [str(vt.id)],
+                    }
+
+                    template["processes"][charging_process_name][
+                        "peq_name"
+                    ] = "charging_curve_power"
+                    template["processes"][charging_process_name]["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
+                        ],
+                        "precision": 0.01,
+                    }
+
+                    del template["processes"][charging_process_name]["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"
@@ -1137,7 +1203,9 @@ def depot_smallest_possible_size(
 
                     # Simulate the depot
                     simulate_scenario(
-                        scenario, smart_charging_strategy=SmartChargingStrategy.NONE
+                        scenario,
+                        smart_charging_strategy=SmartChargingStrategy.NONE,
+                        ignore_unstable_simulation=True,
                     )
 
                     # Find the peak usage of the depot
@@ -1201,12 +1269,6 @@ def depot_smallest_possible_size(
 
                 except MissingVehicleDimensionError as e:
                     raise e
-                except UnstableSimulationException as e:
-                    # This change is made after Unstable exception and delay exceptions are introduced
-                    logger.debug(
-                        f"Results are unstable, suggesting depot is too small."
-                    )
-                    continue
                 except DelayedTripException as e:
                     logger.debug(f"Trips are delayed, suggesting depot is too small.")
                     continue
@@ -1216,6 +1278,10 @@ def depot_smallest_possible_size(
         # Identify the best configuration for each vehicle type
         ret_val: Dict[VehicleType, Dict[AreaType, int]] = dict()
         for vt in vts_and_rotations.keys():
+            assert area_needed[vt] != {}, (
+                f"No valid configurations found for {vt.name}, "
+                f"please check if there are any delays after simulating scenario."
+            )
             best_config = min(area_needed[vt].keys(), key=lambda x: area_needed[vt][x])
             ret_val[vt] = {
                 AreaType.LINE: best_config * standard_block_length,

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

@@ -1,6 +1,7 @@
 import datetime
 import itertools
 import logging
+import math
 import warnings
 from datetime import timedelta
 from typing import List, Dict
@@ -225,8 +226,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 +275,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 +399,11 @@ 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))
+        # TODO this is a bypass of update events having lower energy_real than the event before. It happens in processes L 1304
+        if log.event_name == "update":
+            continue
+
+        battery_log_list.append((log.t, round(log.energy / log.energy_real, 4)))
 
     time_keys = sorted(dict_of_events.keys())
 
@@ -408,15 +416,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 +481,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 (
@@ -466,7 +501,7 @@ def add_events_into_database(
                     '"Standby", "Precondition"'
                 )
 
-        if process_dict["end"] == start_time:
+        if math.ceil(process_dict["end"]) == math.ceil(start_time):
             logger.warning("Refusing to create an event with zero duration.")
             continue
 
@@ -488,6 +523,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=math.ceil(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,
@@ -496,8 +545,9 @@ def add_events_into_database(
             area_id=area_id,
             subloc_no=process_dict["slot"] if "slot" in process_dict.keys() else 00,
             trip_id=None,
-            time_start=timedelta(seconds=start_time) + simulation_start_time,
-            time_end=timedelta(seconds=process_dict["end"]) + simulation_start_time,
+            time_start=timedelta(seconds=math.ceil(start_time)) + simulation_start_time,
+            time_end=timedelta(seconds=math.ceil(process_dict["end"]))
+            + simulation_start_time,
             soc_start=process_dict["soc_start"]
             if process_dict["soc_start"] is not None
             else process_dict["soc_end"],
@@ -507,7 +557,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.9}/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
@@ -99,6 +102,7 @@ def vehicle_type_to_global_constants_dict(vt: VehicleType) -> Dict[str, float]:
         "soc_max": 1.0,
         "soc_init": 1.0,
         "soh": 1.0,
+        "charging_efficiency": vt.charging_efficiency,
     }
     return the_dict
 
@@ -204,7 +208,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 +218,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.9}/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.9}/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(
@@ -839,6 +840,7 @@ class Charge(ChargeAbstract):
 
     @property
     def power(self):
+        # TODO this doesn't consider vehicle charging power
         return self.charging_interface.max_power
 
     def _action(self, *args, **kwargs):
@@ -1239,6 +1241,8 @@ class ChargeEquationSteps(ChargeAbstract):
         self.precision = precision
         Charge.check_soc_target(soc_target, vehicle_filter)
         self.soc_target = soc_target
+        if "precision" in self.peq_params:
+            self.precision = self.peq_params["precision"]
 
     @property
     def power(self):
@@ -1270,8 +1274,12 @@ class ChargeEquationSteps(ChargeAbstract):
                 )
                 soc_target_step = self.vehicle.battery.soc + soc_interval
                 amount = self.vehicle.battery.energy_real * soc_interval
-                effective_power = self.power * self.efficiency
-                self.dur = int(amount / effective_power * 3600)
+                effective_power = (
+                    self.power
+                    * self.efficiency
+                    * self.vehicle.vehicle_type.charging_efficiency
+                )
+                self.dur = round(amount / effective_power * 3600, 12)
 
                 if self.dur == 0:
                     # amount is so small that dur is <1s. Reduce the precision
@@ -1294,6 +1302,7 @@ class ChargeEquationSteps(ChargeAbstract):
                 yield self.env.timeout(self.dur)
 
                 if soc_target_step < self.soc_target:
+                    # TODO why here we have energy higher than the step_soc_target?
                     # recalculate amount because update_battery may have been
                     # called in the meantime
                     amount_step = (
@@ -1428,6 +1437,33 @@ 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
+    """
+
+    precision = peq_params.get("precision", 0.01)
+    current_soc = vehicle.battery.soc
+    p_max = charging_interface.max_power
+    target_step_soc = min(vehicle.battery.soc + precision, vehicle.battery.soc_max)
+
+    power_current_soc = min(
+        p_max, np.interp(current_soc, peq_params["soc"], peq_params["power"])
+    )
+
+    power_target_soc = min(
+        p_max, np.interp(target_step_soc, peq_params["soc"], peq_params["power"])
+    )
+
+    current_power = min(power_current_soc, power_target_soc)
+
+    return float(current_power)
+
+
 class Standby(VehicleProcess):
     """Process of mandatory waiting such as standby times."""
 

{eflips_depot-4.14.3 → eflips_depot-4.15.9}/eflips/depot/rating.py

@@ -422,7 +422,7 @@ class RfdDiffDispatch:
         diffs = []
         for vehicle in area.vehicles:
             etc = vehicle.dwd.etc_processes
-            if isinstance(etc, int):
+            if isinstance(etc, int) or isinstance(etc, float):
                 diff = etc - slot[0].env.now
                 diffs.append(diff)
             # Convert EstimateValue to numerical rfddiff

{eflips_depot-4.14.3 → eflips_depot-4.15.9}/eflips/depot/simple_vehicle.py

@@ -36,7 +36,17 @@ class VehicleType:
 
     """
 
-    def __init__(self, ID, battery_capacity, soc_min, soc_max, soc_init, soh, CR=None):
+    def __init__(
+        self,
+        ID,
+        battery_capacity,
+        soc_min,
+        soc_max,
+        soc_init,
+        soh,
+        charging_efficiency=1.0,
+        CR=None,
+    ):
         self.ID = ID
         self.battery_capacity = battery_capacity
         self.soc_min = soc_min
@@ -45,6 +55,7 @@ class VehicleType:
         self.soh = soh
         self.CR = CR
         self.group = None
+        self.charging_efficiency = charging_efficiency
 
         self.count = {}
         self.share = {}

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "eflips-depot"
-version = "4.14.3"
+version = "4.15.9"
 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]