eflips-depot 4.10.0__tar.gz → 4.12.0__tar.gz

{eflips_depot-4.10.0 → eflips_depot-4.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: eflips-depot
-Version: 4.10.0
+Version: 4.12.0
 Summary: Depot Simulation for eFLIPS
 License: AGPL-3.0-or-later
 Author: Enrico Lauth
@@ -13,8 +13,8 @@ Classifier: Programming Language :: Python :: 3.11
 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 (>=8.1.0,<9.0.0)
-Requires-Dist: eflips-opt (>=0.3.0,<0.4.0)
+Requires-Dist: eflips-model (>8.1.0,<10.0.0)
+Requires-Dist: eflips-opt (>=0.3.3,<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.10.0 → eflips_depot-4.12.0}/eflips/depot/api/__init__.py

@@ -51,6 +51,7 @@ from eflips.model import (
     Route,
     ConsistencyWarning,
     Station,
+    ConsumptionLut,
 )
 from sqlalchemy.orm import Session
 
@@ -59,10 +60,12 @@ from eflips.depot import (
     DepotEvaluation,
     SimulationHost,
 )
+from eflips.depot.api.private.consumption import ConsumptionResult
 from eflips.depot.api.private.consumption import (
     initialize_vehicle,
     add_initial_standby_event,
     attempt_opportunity_charging_event,
+    extract_trip_information,
 )
 from eflips.depot.api.private.depot import (
     delete_depots,
@@ -116,37 +119,42 @@ class SmartChargingStrategy(Enum):
     """
 
 
-@dataclass
-class ConsumptionResult:
+def generate_consumption_result(scenario):
     """
-    A dataclass that stores the results of a charging simulation for a single trip.
-
-    This class holds both the total change in battery State of Charge (SoC) over the trip
-    as well as an optional timeseries of timestamps and incremental SoC changes. When
-    an entry exists for a given trip in ``consumption_result``, the simulation will use
-    these precomputed values instead of recalculating the SoC changes from the vehicle
-    distance and consumption.
-
-    :param delta_soc_total:
-        The total change in the vehicle's State of Charge over the trip, typically
-        negative if the vehicle is consuming energy (e.g., -0.15 means the SoC
-        dropped by 15%).
-
-    :param timestamps:
-        A list of timestamps (e.g., arrival times at stops) that mark the times
-        associated with the SoC changes. The number of timestamps must match the
-        number of entries in ``delta_soc``.
-
-    :param delta_soc:
-        A list of cumulative SoC changes corresponding to the ``timestamps``.
-        For example, if ``delta_soc[i] = -0.02``, it means the SoC decreased by 2%
-        between from the start of the trip to ``timestamps[i]``. This list should typically
-        be a monotonic decreasing sequence.
+    Generate consumption information for the scenario.
+
+    This function retrieves the consumption LUT and vehicle classes from the database and returns a dictionary
+    containing the consumption information for each vehicle type in the scenario. If a trip has no corresponding
+    consumption LUT, it won't be included in the results.
+
+    :param scenario: A :class:`eflips.model.Scenario` object containing the input data for the simulation.
+
+    :return: A dictionary containing the consumption information for each vehicle type in the scenario.
     """
 
-    delta_soc_total: float
-    timestamps: List[datetime] | None
-    delta_soc: List[float] | None
+    with create_session(scenario) as (session, scenario):
+        trips = session.query(Trip).filter(Trip.scenario_id == scenario.id).all()
+        consumption_results = {}
+        for trip in trips:
+            try:
+                consumption_info = extract_trip_information(
+                    trip.id,
+                    scenario,
+                )
+            except ValueError as e:
+                # If the trip has no consumption information, skip it
+                logging.warning(
+                    f"Skipping trip {trip.id} due to missing consumption information: {e}"
+                )
+                continue
+
+            battery_capacity_current_vt = trip.rotation.vehicle_type.battery_capacity
+            consumption_result = consumption_info.generate_consumption_result(
+                battery_capacity_current_vt
+            )
+            consumption_results[trip.id] = consumption_result
+
+    return consumption_results
 
 
 def simple_consumption_simulation(
@@ -1103,6 +1111,7 @@ def generate_depot_optimal_size(
     charging_power: float = 90,
     database_url: Optional[str] = None,
     delete_existing_depot: bool = False,
+    use_consumption_lut: bool = False,
 ) -> None:
     """
     Generates an optimal depot layout with the smallest possible size for each depot in the scenario. Line charging areas
@@ -1114,6 +1123,8 @@ 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.
+        If False, constant consumption stored in VehicleType table will be used.
 
     :return: None. The depot layout will be added to the database.
 
@@ -1135,19 +1146,20 @@ def generate_depot_optimal_size(
 
             delete_depots(scenario, session)
 
-        # Temporary workaround to set vehicle energy consumption manually
-        # TODO: Replace by "use DS consumption if LUT"
-        for vehicle_type in (
-            session.query(VehicleType)
-            .filter(VehicleType.scenario_id == scenario.id)
-            .all()
-        ):
-            vehicle_type.consumption = 2.0
-            vehicle_type.vehicle_classes = []
-
         ##### Step 0: Consumption Simulation #####
         # Run the consumption simulation for all depots
-        simple_consumption_simulation(scenario, initialize_vehicles=True)
+
+        if use_consumption_lut:
+            # If using the consumption lookup table, we need to calculate the consumption results
+            consumption_results = generate_consumption_result(scenario)
+            simple_consumption_simulation(
+                scenario,
+                initialize_vehicles=True,
+                consumption_result=consumption_results,
+            )
+        else:
+            # If not using the consumption lookup table, we need to initialize the vehicles with the constant consumption
+            simple_consumption_simulation(scenario, initialize_vehicles=True)
 
         ##### Step 1: Find all potential depots #####
         # These are all the spots where a rotation starts and end
@@ -1216,21 +1228,22 @@ def generate_depot_optimal_size(
 
     # create depot with the calculated area sizes
 
-    for depot_station, capacities in depot_capacities_for_scenario.items():
-        generate_depot(
-            capacities,
-            depot_station,
-            scenario,
-            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,
-        )
+    with create_session(scenario, database_url) as (session, scenario):
+        for depot_station, capacities in depot_capacities_for_scenario.items():
+            generate_depot(
+                capacities,
+                depot_station,
+                scenario,
+                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,
+            )
 
-    # Delete all vehicles and events again. Only depot layout is kept
+        # Delete all vehicles and events again. Only depot layout is kept
 
-    rotation_q = session.query(Rotation).filter(Rotation.scenario_id == scenario.id)
-    rotation_q.update({"vehicle_id": None})
-    session.query(Event).filter(Event.scenario_id == scenario.id).delete()
-    session.query(Vehicle).filter(Vehicle.scenario_id == scenario.id).delete()
+        rotation_q = session.query(Rotation).filter(Rotation.scenario_id == scenario.id)
+        rotation_q.update({"vehicle_id": None})
+        session.query(Event).filter(Event.scenario_id == scenario.id).delete()
+        session.query(Vehicle).filter(Vehicle.scenario_id == scenario.id).delete()

{eflips_depot-4.10.0 → eflips_depot-4.12.0}/eflips/depot/api/private/consumption.py

@@ -1,9 +1,11 @@
 import logging
 import warnings
+from dataclasses import dataclass
 from datetime import timedelta, datetime
 from math import ceil
-from typing import Tuple
+from typing import Tuple, List
 from zoneinfo import ZoneInfo
+import scipy
 
 import numpy as np
 import sqlalchemy.orm
@@ -12,11 +14,281 @@ from eflips.model import (
     EventType,
     Rotation,
     Vehicle,
+    VehicleType,
+    VehicleClass,
     Trip,
     Station,
     ChargeType,
     ConsistencyWarning,
+    ConsumptionLut,
+    Scenario,
 )
+from sqlalchemy.orm import joinedload
+
+from eflips.depot.api.private.util import temperature_for_trip, create_session
+
+
+@dataclass
+class ConsumptionResult:
+    """
+    A dataclass that stores the results of a charging simulation for a single trip.
+
+    This class holds both the total change in battery State of Charge (SoC) over the trip
+    as well as an optional timeseries of timestamps and incremental SoC changes. When
+    an entry exists for a given trip in ``consumption_result``, the simulation will use
+    these precomputed values instead of recalculating the SoC changes from the vehicle
+    distance and consumption.
+
+    :param delta_soc_total:
+        The total change in the vehicle's State of Charge over the trip, typically
+        negative if the vehicle is consuming energy (e.g., -0.15 means the SoC
+        dropped by 15%).
+
+    :param timestamps:
+        A list of timestamps (e.g., arrival times at stops) that mark the times
+        associated with the SoC changes. The number of timestamps must match the
+        number of entries in ``delta_soc``.
+
+    :param delta_soc:
+        A list of cumulative SoC changes corresponding to the ``timestamps``.
+        For example, if ``delta_soc[i] = -0.02``, it means the SoC decreased by 2%
+        between from the start of the trip to ``timestamps[i]``. This list should typically
+        be a monotonic decreasing sequence.
+    """
+
+    delta_soc_total: float
+    timestamps: List[datetime] | None
+    delta_soc: List[float] | None
+
+
+@dataclass
+class ConsumptionInformation:
+    """
+    A dataclass to hold the information needed for the consumption simulation.
+
+    :param trip_id:
+        The ID of the trip for which the consumption is calculated.
+    :param consumption_lut:
+        The ConsumptionLut object for the vehicle class. This is used to calculate the
+        consumption based on the trip parameters.
+    :param average_speed:
+        The average speed of the trip in km/h. This is used to calculate the consumption.
+    :param distance:
+        The distance of the trip in km. This is used to calculate the total consumption.
+    :param temperature:
+        The ambient temperature in °C. This is used to calculate the consumption.
+    :param level_of_loading:
+        The level of loading of the vehicle as a fraction of its maximum payload.
+    :param incline:
+        The incline of the trip as a fraction (0.0-1.0). This is used to calculate the consumption.
+    :param consumption:
+        The total consumption of the trip in kWh. This is calculated based on the LUT and trip parameters.
+    :param consumption_per_km:
+        The consumption per km in kWh. This is calculated based on the LUT and trip parameters.
+    """
+
+    trip_id: int
+    consumption_lut: ConsumptionLut | None  # 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
+    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
+
+    def calculate(self):
+        """
+        Calculates the consumption for the trip. Returns a float in kWh.
+
+        :return: The energy consumption in kWh. This is already the consumption for the whole trip.
+        """
+
+        # Make sure the consumption lut has 4 dimensions and the columns are in the correct order
+        if self.consumption_lut.columns != [
+            "incline",
+            "t_amb",
+            "level_of_loading",
+            "mean_speed_kmh",
+        ]:
+            raise ValueError(
+                "The consumption LUT must have the columns 'incline', 't_amb', 'level_of_loading', 'mean_speed_kmh'"
+            )
+
+        # Recover the scales along each of the four axes from the datapoints
+        incline_scale = sorted(set([x[0] for x in self.consumption_lut.data_points]))
+        temperature_scale = sorted(
+            set([x[1] for x in self.consumption_lut.data_points])
+        )
+        level_of_loading_scale = sorted(
+            set([x[2] for x in self.consumption_lut.data_points])
+        )
+        speed_scale = sorted(set([x[3] for x in self.consumption_lut.data_points]))
+
+        # Create the 4d array
+        consumption_lut = np.zeros(
+            (
+                len(incline_scale),
+                len(temperature_scale),
+                len(level_of_loading_scale),
+                len(speed_scale),
+            )
+        )
+
+        # Fill it with NaNs
+        consumption_lut.fill(np.nan)
+
+        for i, (incline, temperature, level_of_loading, speed) in enumerate(
+            self.consumption_lut.data_points
+        ):
+            consumption_lut[
+                incline_scale.index(incline),
+                temperature_scale.index(temperature),
+                level_of_loading_scale.index(level_of_loading),
+                speed_scale.index(speed),
+            ] = self.consumption_lut.values[i]
+
+        # Interpolate the consumption
+        interpolator = scipy.interpolate.RegularGridInterpolator(
+            (incline_scale, temperature_scale, level_of_loading_scale, speed_scale),
+            consumption_lut,
+            bounds_error=False,
+            fill_value=None,
+            method="linear",
+        )
+        consumption_per_km = interpolator(
+            [self.incline, self.temperature, self.level_of_loading, self.average_speed]
+        )[0]
+
+        # This is a temporary workaround to handle cases where the LUT does not contain
+        if consumption_per_km is None or np.isnan(consumption_per_km):
+            # Add a warning if we had to use nearest neighbor interpolation
+            warnings.warn(
+                f"Consumption LUT for trip {self.trip_id} with parameters: "
+                f"incline={self.incline}, temperature={self.temperature}, "
+                f"level_of_loading={self.level_of_loading}, average_speed={self.average_speed} "
+                f"returned NaN. Using nearest neighbor interpolation instead. The result may be less accurate.",
+                ConsistencyWarning,
+            )
+
+            interpolator_nn = scipy.interpolate.RegularGridInterpolator(
+                (incline_scale, temperature_scale, level_of_loading_scale, speed_scale),
+                consumption_lut,
+                bounds_error=False,
+                fill_value=None,  # Fill NaN with 0.0
+                method="nearest",
+            )
+            consumption_per_km = interpolator_nn(
+                [
+                    self.incline,
+                    self.temperature,
+                    self.level_of_loading,
+                    self.average_speed,
+                ]
+            )[0]
+
+            # Add a warning if we had to use nearest neighbor interpolation
+
+        if consumption_per_km is None or np.isnan(consumption_per_km):
+            raise ValueError(
+                f"Could not calculate consumption for trip {self.trip_id} with parameters: "
+                f"incline={self.incline}, temperature={self.temperature}, "
+                f"level_of_loading={self.level_of_loading}, average_speed={self.average_speed}. "
+                f"Possible reason: data points missing in the LUT."
+            )
+
+        self.consumption = consumption_per_km * self.distance
+        self.consumption_per_km = consumption_per_km
+        self.consumption_lut = None  # To save memory
+
+    def generate_consumption_result(self, battery_capacity) -> ConsumptionResult:
+        """
+        Generates a ConsumptionResult object from the current instance.
+
+        :param battery_capacity: The battery capacity in kWh.
+        :return: A ConsumptionResult object containing the total change in SoC and optional timeseries.
+        """
+        if self.consumption is None:
+            raise ValueError(
+                "Consumption must be calculated before generating a result."
+            )
+
+        # TODO implement a timeseries of timestamps and delta_soc
+        consumption_result = ConsumptionResult(
+            delta_soc_total=-float(self.consumption) / battery_capacity,
+            timestamps=None,
+            delta_soc=None,
+        )
+        return consumption_result
+
+
+def extract_trip_information(
+    trip_id: int,
+    scenario: Scenario,
+    passenger_mass=68,
+    passenger_count=17.6,
+) -> ConsumptionInformation:
+    """
+    Extracts the information needed for the consumption simulation from a trip.
+    """
+
+    with create_session(scenario) as (session, scenario):
+        # Load the trip with its route and rotation, including vehicle type and consumption LUT
+        # We use joinedload to avoid N+1 queries
+
+        trip = (
+            session.query(Trip)
+            .filter(Trip.id == trip_id)
+            .options(joinedload(Trip.route))
+            .options(
+                joinedload(Trip.rotation)
+                .joinedload(Rotation.vehicle_type)
+                .joinedload(VehicleType.vehicle_classes)
+                .joinedload(VehicleClass.consumption_lut)
+            )
+            .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 = (
+            trip.arrival_time - trip.departure_time
+        ).total_seconds() / 3600
+        average_speed = total_distance / total_duration  # km/h
+
+        temperature = temperature_for_trip(trip_id, session)
+
+        payload_mass = passenger_mass * passenger_count
+        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,
+        )
+
+        info.calculate()
+    return info
 
 
 def initialize_vehicle(rotation: Rotation, session: sqlalchemy.orm.session.Session):

{eflips_depot-4.10.0 → eflips_depot-4.12.0}/eflips/depot/api/private/results_to_database.py

@@ -67,7 +67,7 @@ def get_finished_schedules_per_vehicle(
             }
             if i == 0:
                 raise UnstableSimulationException(
-                    f"New Vehicle required for the trip {current_trip.ID}, which suggests the fleet or the "
+                    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 ."
                 )

{eflips_depot-4.10.0 → eflips_depot-4.12.0}/eflips/depot/api/private/util.py

@@ -7,6 +7,7 @@ from datetime import timedelta, datetime
 from typing import Union, Any, Optional, Tuple, Dict, List
 
 import simpy
+import numpy as np
 from eflips.model import (
     Scenario,
     VehicleType,
@@ -15,6 +16,7 @@ from eflips.model import (
     EventType,
     Trip,
     Depot,
+    Temperatures,
 )
 from sqlalchemy import inspect, create_engine
 from sqlalchemy.orm import Session
@@ -199,6 +201,38 @@ def check_depot_validity(depot: Depot) -> None:
         ), "All processes except the last one must have electric power."
 
 
+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.
+
+    :param trip_id: The ID of the trip
+    :param session: The SQLAlchemy session
+    :return: A temperature in °C
+    """
+
+    trip = session.query(Trip).filter(Trip.id == trip_id).one()
+    temperatures = (
+        session.query(Temperatures)
+        .filter(Temperatures.scenario_id == trip.scenario_id)
+        .one()
+    )
+
+    # Find the mid-point of the trip
+    mid_time = trip.departure_time + (trip.arrival_time - trip.departure_time) / 2
+
+    if temperatures.use_only_time:
+        # The temperatures are only given by time. We change our mid-time to be the date of the temperatures
+        mid_time = datetime.combine(temperatures.datetimes[0].date(), mid_time.time())
+
+    mid_time = mid_time.timestamp()
+
+    datetimes = [dt.timestamp() for dt in temperatures.datetimes]
+    temperatures = temperatures.data
+
+    temperature = np.interp(mid_time, datetimes, temperatures)
+    return float(temperature)
+
+
 @dataclass
 class VehicleSchedule:
     """

{eflips_depot-4.10.0 → eflips_depot-4.12.0}/eflips/depot/depot.py

@@ -1514,6 +1514,10 @@ class DepotControl:
 
     def schedule_for_matching(self, trip):
         """Wait *delay* and then schedule *trip* for matching with a vehicle."""
+
+        # Shuyao: This delay does not mean the trip is delayed. It means the trip must be scheduled one hour before departure
+        # so the time of the environment is "delayed" until 1 hour before departure.
+
         delay = self.dispatch_strategy.scheduling_delay(self.env, trip)
         yield self.env.timeout(delay)
         self.depot.unassigned_trips.append(trip)

{eflips_depot-4.10.0 → eflips_depot-4.12.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "eflips-depot"
-version = "4.10.0"
+version = "4.12.0"
 description = "Depot Simulation for eFLIPS"
 authors = ["Enrico Lauth <enrico.lauth@tu-berlin.de>",
     "Ludger Heide <ludger.heide@tu-berlin.de",
@@ -22,8 +22,8 @@ xlsxwriter = "^3.1.9"
 pandas = "^2.2.0"
 xlrd = "<=1.2.0"
 scipy = "^1.14.0"
-eflips-model = "^8.1.0"
-eflips-opt = "^0.3.0"
+eflips-model = ">8.1.0, <10.0.0"
+eflips-opt = "^0.3.3"
 
 
 [tool.pytest.ini_options]