eflips-depot 3.1.5__py3-none-any.whl → 3.2.0__py3-none-any.whl

eflips/depot/api/__init__.py

@@ -28,6 +28,7 @@ import copy
 import os
 import warnings
 from datetime import timedelta
+from enum import Enum, auto
 from math import ceil
 from typing import Any, Dict, Optional, Union
 
@@ -56,6 +57,7 @@ from eflips.depot.api.private.depot import (
     depot_to_template,
     group_rotations_by_start_end_stop,
 )
+from eflips.depot.api.private.smart_charging import optimize_charging_events_even
 from eflips.depot.api.private.util import (
     create_session,
     repeat_vehicle_schedules,
@@ -65,6 +67,32 @@ from eflips.depot.api.private.util import (
 )
 
 
+class SmartChargingStragegy(Enum):
+    """Enum class for different smart charging strategies."""
+
+    NONE = auto
+    """
+    Do not use smart charging.
+
+    Buses are charged with the maximum power available, from the time they arrive at the depot
+    until they are full (or leave the depot).
+    """
+    EVEN = auto
+    """
+    Use smart charging with an even distribution of charging power over the time the bus is at the depot.
+
+    This aims to
+    minimize the peak power demand.
+    """
+    MIN_PRICE = auto
+    """
+    Use smart charging in order to minimize the cost of charging.
+
+    The price profile can be specified using the
+    PRICE_PROFILE environment variable. If this is not set, the price is loaded using an API.
+    """
+
+
 def simple_consumption_simulation(
     scenario: Union[Scenario, int, Any],
     initialize_vehicles: bool,
@@ -350,10 +378,85 @@ def generate_depot_layout(
             )
 
 
+def apply_even_smart_charging(
+    scenario: Union[Scenario, int, Any],
+    database_url: Optional[str] = None,
+    standby_departure_duration: timedelta = timedelta(minutes=5),
+) -> None:
+    """
+    Takes a scenario where depot simulation has been run and applies smart charging to the depot.
+
+    This modifies the
+    time and power of the charging events in the database. The arrival and departure times and SoCs at these times are
+    not modified.
+
+    :param scenario: A :class:`eflips.model.Scenario` object containing the input data for the simulation.
+    :param database_url: An optional database URL. If no database URL is passed and the `scenario` parameter is not a
+        :class:`eflips.model.Scenario` object, the environment variable `DATABASE_URL` must be set to a valid database
+        URL.
+    :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.
+    :return: None. The results are added to the database.
+    """
+    with create_session(scenario, database_url) as (session, scenario):
+        depots = session.query(Depot).filter(Depot.scenario_id == scenario.id).all()
+        for depot in depots:
+            # Load all the charging events at this depot
+            charging_events = (
+                session.query(Event)
+                .join(Area)
+                .filter(Area.depot_id == depot.id)
+                .filter(Event.event_type == EventType.CHARGING_DEPOT)
+                .all()
+            )
+
+            # For each event, take the subsequent STANDBY_DEPARTURE event of the same vehicle
+            # Reduce the STANDBY_DEPARTURE events duration to 5 minutes
+            # Move the end time of the charging event to the start time of the STANDBY_DEPARTURE event
+            for charging_event in charging_events:
+                next_event = (
+                    session.query(Event)
+                    .filter(Event.time_start >= charging_event.time_end)
+                    .filter(Event.vehicle_id == charging_event.vehicle_id)
+                    .order_by(Event.time_start)
+                    .first()
+                )
+                assert next_event is not None
+                assert next_event.event_type == EventType.STANDBY_DEPARTURE
+                assert next_event.time_start == charging_event.time_end
+
+                if (
+                    next_event.time_end - next_event.time_start
+                ) > standby_departure_duration:
+                    next_event.time_start = (
+                        next_event.time_end - standby_departure_duration
+                    )
+                    session.flush()
+                    # Add a timeseries to the charging event
+                    assert charging_event.timeseries is None
+                    charging_event.timeseries = {
+                        "time": [
+                            charging_event.time_start.isoformat(),
+                            charging_event.time_end.isoformat(),
+                            next_event.time_start.isoformat(),
+                        ],
+                        "soc": [
+                            charging_event.soc_start,
+                            charging_event.soc_end,
+                            charging_event.soc_end,
+                        ],
+                    }
+                    charging_event.time_end = next_event.time_start
+                    session.flush()
+
+            optimize_charging_events_even(charging_events)
+
+
 def simulate_scenario(
     scenario: Union[Scenario, int, Any],
     repetition_period: Optional[timedelta] = None,
     database_url: Optional[str] = None,
+    smart_charging_strategy: SmartChargingStragegy = SmartChargingStragegy.EVEN,
 ) -> None:
     """
     This method simulates a scenario and adds the results to the database.
@@ -375,11 +478,15 @@ def simulate_scenario(
     :param database_url: An optional database URL. If no database URL is passed and the `scenario` parameter is not a
         :class:`eflips.model.Scenario` object, the environment variable `DATABASE_URL` must be set to a valid database
         URL.
+    :param smart_charging_strategy: An optional parameter specifying the smart charging strategy to be used. The
+        default is SmartChargingStragegy.NONE. The following strategies are available:
+        - SmartChargingStragegy.NONE: Do not use smart charging. Buses are charged with the maximum power available,
+        from the time they arrive at the depot until they are full (or leave the depot).
+        - SmartChargingStragegy.EVEN: Use smart charging with an even distribution of charging power over the time the
+        bus is at the depot. This aims to minimize the peak power demand.
 
     :return: Nothing. The results are added to the database.
     """
-
-    # Step 0: Load the scenario
     with create_session(scenario, database_url) as (session, scenario):
         simulation_host = init_simulation(
             scenario=scenario,
@@ -389,6 +496,16 @@ def simulate_scenario(
         ev = run_simulation(simulation_host)
         add_evaluation_to_database(scenario, ev, session)
 
+    match smart_charging_strategy:
+        case SmartChargingStragegy.NONE:
+            pass
+        case SmartChargingStragegy.EVEN:
+            apply_even_smart_charging(scenario, database_url)
+        case SmartChargingStragegy.MIN_PRICE:
+            raise NotImplementedError("MIN_PRICE strategy is not implemented yet.")
+        case _:
+            raise NotImplementedError()
+
 
 def _init_simulation(
     scenario: Scenario,

eflips/depot/api/private/smart_charging.py

@@ -0,0 +1,257 @@
+from datetime import timedelta, datetime
+from typing import List, Dict
+
+import numpy as np
+import scipy
+from eflips.model import Event, EventType
+
+
+def optimize_charging_events_even(charging_events: List[Event]) -> None:
+    """
+    This function optimizes the power draw of a list of charging events.
+
+    The power draw is optimized such that the total
+    power draw is minimized, while the energy transferred remains constant.
+    :param charging_events: The list of charging events to optimize
+    :return: Nothing, the charging events are updated in place
+    """
+
+    TEMPORAL_RESOLUTION = timedelta(seconds=60)
+
+    assert all(
+        [event.event_type == EventType.CHARGING_DEPOT for event in charging_events]
+    )
+    start_time = min([event.time_start for event in charging_events])
+    end_time = max([event.time_end for event in charging_events])
+
+    # Formulate the optimzation problem.
+    # - Each charging event has a peak power, which cannot be exceeded.
+    # - Each charging event has a start and end time.
+    # - betweeen the start time and end time, the energy transferred must remain constant.
+    # - the total power draw is the sum of all events' power at this point in time
+    # - the total power draw must be minimized
+
+    total_duration = int((end_time - start_time) / TEMPORAL_RESOLUTION)
+    total_time = np.arange(
+        start_time.timestamp(),
+        end_time.timestamp(),
+        TEMPORAL_RESOLUTION.total_seconds(),
+    )  # The time axis, used to resample the power draw
+
+    # For each event, create an array of power draws and a boolean array of charging allowed
+    # Also note down the peak power and transferred energy
+    params_for_events: List[Dict[str, float | np.ndarray]] = []
+    for event in charging_events:
+        power_draw = np.zeros(total_duration, dtype=float)
+        charging_allowed = np.zeros(total_duration, dtype=int)
+
+        # Calculate the power draw vector, from the start SoC, end SoC and timeseries, if available
+        event_soc = [event.soc_start]
+        event_time = [event.time_start.timestamp()]
+        if event.timeseries is not None:
+            event_soc.extend(event.timeseries["soc"])
+            event_time.extend(
+                [
+                    datetime.fromisoformat(t).timestamp()
+                    for t in event.timeseries["time"]
+                ]
+            )
+        event_soc.append(event.soc_end)
+        event_time.append(event.time_end.timestamp())
+
+        # Resample the timeseries to the temporal resolution
+        expanded_soc = np.interp(total_time, event_time, event_soc)
+        expanded_power = (
+            np.diff(expanded_soc, prepend=expanded_soc[0])
+            * event.vehicle.vehicle_type.battery_capacity
+        )  # Change in kWh each minute
+        expanded_power = (
+            expanded_power / TEMPORAL_RESOLUTION.total_seconds() * 3600
+        )  # to kW
+
+        # Between the start and end time, charging is allowed
+        start_index = int((event.time_start - start_time) / TEMPORAL_RESOLUTION)
+        end_index = int((event.time_end - start_time) / TEMPORAL_RESOLUTION)
+        charging_allowed[start_index:end_index] = 1
+        max_power = max(expanded_power)
+        transferred_energy = (
+            event_soc[-1] - event_soc[0]
+        ) * event.vehicle.vehicle_type.battery_capacity  # kWh
+
+        params_for_events.append(
+            {
+                "power_draw": expanded_power,
+                "charging_allowed": charging_allowed,
+                "max_power": max_power,
+                "transferred_energy": transferred_energy,
+            }
+        )
+
+    # The total number of vehicles at the depot is the sum of the charging allowed for each event, since it is 1 if
+    # the bus is at the depot and 0 otherwise
+    total_occupancy = np.sum(
+        [event["charging_allowed"] for event in params_for_events], axis=0
+    )
+
+    # For each event, calculate an optimized power draw
+    for params_for_event in params_for_events:
+        # Calculate the mean power that would be drawn if the vehicle was charged evenly
+        charging_duration = (
+            np.sum(params_for_event["charging_allowed"])
+            * TEMPORAL_RESOLUTION.total_seconds()
+        )
+        mean_power = (
+            params_for_event["transferred_energy"] / charging_duration
+        ) * 3600  # kW
+
+        # Calculate the mean amount of vehicles present at the depot when this vehicle is charging
+        # We only consider the time when the vehicle is charging
+        total_occupancy_while_charging = total_occupancy[
+            params_for_event["charging_allowed"] == 1
+        ]
+        mean_occupancy = np.mean(total_occupancy_while_charging)
+
+        # for each timestep optimize the power draw. We want to charge less when there are more vehicles at the depot
+        # The power draw is varies with the amount of vehicles present at the depot relative to the mean amount
+        charging_factor = (mean_occupancy / (total_occupancy)) * params_for_event[
+            "charging_allowed"
+        ]
+
+        # Make sure the charging factor is not infinite or NaN
+        charging_factor[np.isnan(charging_factor)] = 1
+        charging_factor[np.isinf(charging_factor)] = 1
+        optimized_power = (
+            params_for_event["charging_allowed"] * mean_power * charging_factor
+        )
+
+        # Cap it at the peak power
+        optimized_power_capped = np.minimum(
+            optimized_power, params_for_event["max_power"]
+        )
+
+        # Count the energy that is we need to distribute over the time when the vehicle is not at peak power
+        energy_to_distribute = (
+            np.trapz((optimized_power - optimized_power_capped), total_time) / 3600
+        )  # kWh
+        if energy_to_distribute > 0:
+            optimized_power_not_capped = np.where(
+                optimized_power > optimized_power_capped
+            )
+            # Distribute the energy over the time when the vehicle is not at peak power
+            uncapped_duration = (
+                optimized_power_not_capped[0].shape[0]
+                * TEMPORAL_RESOLUTION.total_seconds()
+            )
+            power_to_add = energy_to_distribute / (uncapped_duration / 3600)
+            optimized_power[optimized_power_not_capped[0]] += power_to_add
+
+        # Make sure the transferred energy is the same
+        post_opt_energy = (
+            scipy.integrate.trapz(optimized_power, total_time) / 3600
+        )  # kWh
+        assert post_opt_energy >= params_for_event["transferred_energy"]
+        # Make it fit exactly
+        optimized_power = optimized_power * (
+            params_for_event["transferred_energy"] / post_opt_energy
+        )
+
+        optimized_power2 = (
+            params_for_event["charging_allowed"] * mean_power
+        )  # * (mean_occupancy / total_occupancy)
+        # Fill NaNs with the zero power draw
+        optimized_power[np.isnan(optimized_power)] = 0
+        optimized_power2[np.isnan(optimized_power2)] = 0
+
+        params_for_event["optimized_power"] = optimized_power
+        params_for_event["optimized_power2"] = optimized_power2
+
+    # Now we have the power draw and charging allowed for each event
+    if False:
+        from matplotlib import pyplot as plt
+
+        plt.subplot(3, 1, 1)
+        total_power = np.sum(
+            [event["power_draw"] for event in params_for_events], axis=0
+        )
+        plt.plot(total_time, total_power, label="Original power draw")
+        optimized_power = np.sum(
+            [event["optimized_power"] for event in params_for_events], axis=0
+        )
+        plt.plot(total_time, optimized_power, label="Optimized power draw")
+        optimized_power2 = np.sum(
+            [event["optimized_power2"] for event in params_for_events], axis=0
+        )
+        plt.plot(total_time, optimized_power2, label="Mean power draw")
+        plt.xlabel("Time")
+        plt.ylabel("Total power draw (kW)")
+
+        plt.axhline(
+            y=max(total_power), color="blue", linestyle="--", label="Max power draw"
+        )
+        plt.axhline(
+            y=max(optimized_power),
+            color="orange",
+            linestyle="--",
+            label="Max optimized power draw",
+        )
+        plt.axhline(
+            y=max(optimized_power2),
+            color="green",
+            linestyle="--",
+            label="Max mean power draw",
+        )
+
+        plt.subplot(3, 1, 2)
+        # Energy transferred
+        total_energy = scipy.integrate.cumtrapz(total_power, total_time, initial=0)
+        plt.plot(total_time, total_energy, label="Original energy transferred")
+        optimized_energy = scipy.integrate.cumtrapz(
+            optimized_power, total_time, initial=0
+        )
+        plt.plot(total_time, optimized_energy, label="Optimized energy transferred")
+        optimized_energy2 = scipy.integrate.cumtrapz(
+            optimized_power2, total_time, initial=0
+        )
+        plt.plot(total_time, optimized_energy2, label="Mean energy transferred")
+        plt.xlabel("Time")
+        plt.ylabel("Total energy transferred (kWh)")
+
+        plt.subplot(3, 1, 3)
+        plt.plot(total_time, total_occupancy)
+        plt.xlabel("Time")
+        plt.ylabel("Vehicle count")
+        plt.show()
+
+    # Finally, update the events in the database
+    for i in range(len(charging_events)):
+        event = charging_events[i]
+        start_index = int((event.time_start - start_time) / TEMPORAL_RESOLUTION)
+        end_index = int((event.time_end - start_time) / TEMPORAL_RESOLUTION)
+        powers = params_for_events[i]["optimized_power"][start_index:end_index]
+        energies = scipy.integrate.cumtrapz(powers, initial=0) / (
+            3600 / TEMPORAL_RESOLUTION.total_seconds()
+        )  # kWh
+        socs = event.soc_start + energies / event.vehicle.vehicle_type.battery_capacity
+
+        # Make sure the last SoC is the same as the end SoC
+        assert np.isclose(socs[-1], event.soc_end, atol=0.01)
+        # Make sure the first SoC is the same as the start SoC
+        assert np.isclose(socs[0], event.soc_start, atol=0.01)
+
+        # Make the socs match exactly, setting all those smaller than the start SoC to the start SoC and
+        # all those larger than the end SoC to the end SoC
+        socs[socs < event.soc_start] = event.soc_start
+        socs[socs > event.soc_end] = event.soc_end
+
+        # Add a timeseries to the event
+        event.timeseries = {
+            "time": [
+                datetime.fromtimestamp(t).astimezone().isoformat()
+                for t in total_time[start_index:end_index]
+            ],
+            "soc": socs.tolist(),
+        }
+        if event.timeseries["time"][0] < event.time_start.isoformat():
+            event.timeseries["time"][0] = event.time_start.isoformat()
+        if event.timeseries["time"][-1] > event.time_end.isoformat():
+            event.timeseries["time"][-1] = event.time_end.isoformat()

{eflips_depot-3.1.5.dist-info → eflips_depot-3.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: eflips-depot
-Version: 3.1.5
+Version: 3.2.0
 Summary: Depot Simulation for eFLIPS
 Home-page: https://github.com/mpm-tu-berlin/eflips-depot
 License: AGPL-3.0-or-later
@@ -13,8 +13,9 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: eflips (>=0.1.3,<0.2.0)
-Requires-Dist: eflips-model (>=3.2.0,<4.0.0)
+Requires-Dist: eflips-model (>=3.3.0,<4.0.0)
 Requires-Dist: pandas (>=2.1.4,<3.0.0)
+Requires-Dist: scipy (>=1.13.1,<2.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)

{eflips_depot-3.1.5.dist-info → eflips_depot-3.2.0.dist-info}/RECORD

@@ -1,8 +1,9 @@
 eflips/depot/__init__.py,sha256=n7jte8R6j_Ad4Mp4hkklKwil5r8u8Q_SbXrCC-nf5jM,1556
-eflips/depot/api/__init__.py,sha256=iv0BYyGYrhTs-DsAaqFv4CVtgY6WLZ3ga4TuiKBb_J8,51939
+eflips/depot/api/__init__.py,sha256=sSNY1CBO2AmekxdNi-o_mCbWUlMpsBUfVaYT6jYFuxo,57378
 eflips/depot/api/defaults/default_settings.json,sha256=0eUDTw_rtLQFvthP8oJL93iRXlmAOravAg-4qqGMQAY,5375
 eflips/depot/api/private/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 eflips/depot/api/private/depot.py,sha256=GlIk6vuanbQP3a4e9TYt6xJ-XJTdaFbaxxz_ni17zgo,17136
+eflips/depot/api/private/smart_charging.py,sha256=lCocbtFtMY3X5dIOu4OLsSl_Hsasz4FHe1ZzDkiCH-Y,10902
 eflips/depot/api/private/util.py,sha256=zyU3QtsyrYRgcLWzzUT1hQLDfkwlbvvukmgnrANEzlc,15362
 eflips/depot/configuration.py,sha256=Op3hlir-dEN7yHr0kTqbYANoCBKFWK6uKOv3NJl8w_w,35678
 eflips/depot/depot.py,sha256=afIlaiX-J-M5-K_oAGMr_soL3_QjIAwrQKDaZzTwle0,105566
@@ -34,7 +35,7 @@ eflips/depot/simulation.py,sha256=ee0qTzOzG-8ybN36ie_NJallXfC7jUaS9JZvaYFziLs,10
 eflips/depot/smart_charging.py,sha256=C3BYqzn2-OYY4ipXm0ETtavbAM9QXZMYULBpVoChf0E,54311
 eflips/depot/standalone.py,sha256=VxcTzBaB67fNJUMmjPRwKXjhqTy6oQ41Coote2LvAmk,22338
 eflips/depot/validation.py,sha256=TIuY7cQtEJI4H2VVMSuY5IIVkacEEZ67weeMuY3NSAM,7097
-eflips_depot-3.1.5.dist-info/LICENSE.md,sha256=KB4XTk1fPHjtZCYDyPyreu6h1LVJVZXYg-5vePcWZAc,34143
-eflips_depot-3.1.5.dist-info/METADATA,sha256=ls1m7prqFHvVKI9mJz5jvywqjYg06mmhIid6MTiOvfU,5809
-eflips_depot-3.1.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-eflips_depot-3.1.5.dist-info/RECORD,,
+eflips_depot-3.2.0.dist-info/LICENSE.md,sha256=KB4XTk1fPHjtZCYDyPyreu6h1LVJVZXYg-5vePcWZAc,34143
+eflips_depot-3.2.0.dist-info/METADATA,sha256=NGC3zkAfRKAiqTXJ-URaEVjX1ro6vk0R_r4DE_jgmtM,5848
+eflips_depot-3.2.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+eflips_depot-3.2.0.dist-info/RECORD,,