eflips-depot 3.2.3__tar.gz → 3.2.5__tar.gz

{eflips_depot-3.2.3 → eflips_depot-3.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: eflips-depot
-Version: 3.2.3
+Version: 3.2.5
 Summary: Depot Simulation for eFLIPS
 Home-page: https://github.com/mpm-tu-berlin/eflips-depot
 License: AGPL-3.0-or-later

{eflips_depot-3.2.3 → eflips_depot-3.2.5}/eflips/depot/api/__init__.py

@@ -28,7 +28,7 @@ import copy
 import os
 import warnings
 from datetime import timedelta
-from enum import Enum, auto
+from enum import Enum
 from math import ceil
 from typing import Any, Dict, Optional, Union
 
@@ -68,24 +68,24 @@ from eflips.depot.api.private.util import (
 )
 
 
-class SmartChargingStragegy(Enum):
+class SmartChargingStrategy(Enum):
     """Enum class for different smart charging strategies."""
 
-    NONE = auto
+    NONE = 0
     """
     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
+    EVEN = 1
     """
     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
+    MIN_PRICE = 2
     """
     Use smart charging in order to minimize the cost of charging.
 
@@ -422,8 +422,17 @@ def apply_even_smart_charging(
                     .order_by(Event.time_start)
                     .first()
                 )
-                assert next_event is not None
-                assert next_event.event_type == EventType.STANDBY_DEPARTURE
+
+                if (
+                    next_event is None
+                    or next_event.event_type != EventType.STANDBY_DEPARTURE
+                ):
+                    warnings.warn(
+                        f"Event {charging_event.id} has no STANDBY_DEPARTURE event after a CHARGING_DEPOT "
+                        f"event. No room for smart charging."
+                    )
+                    continue
+
                 assert next_event.time_start == charging_event.time_end
 
                 if (
@@ -457,7 +466,7 @@ def simulate_scenario(
     scenario: Union[Scenario, int, Any],
     repetition_period: Optional[timedelta] = None,
     database_url: Optional[str] = None,
-    smart_charging_strategy: SmartChargingStragegy = SmartChargingStragegy.EVEN,
+    smart_charging_strategy: SmartChargingStrategy = SmartChargingStrategy.EVEN,
 ) -> None:
     """
     This method simulates a scenario and adds the results to the database.
@@ -497,15 +506,15 @@ 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()
+        match smart_charging_strategy:
+            case SmartChargingStrategy.NONE:
+                pass
+            case SmartChargingStrategy.EVEN:
+                apply_even_smart_charging(scenario, database_url)
+            case SmartChargingStrategy.MIN_PRICE:
+                raise NotImplementedError("MIN_PRICE strategy is not implemented yet.")
+            case _:
+                raise NotImplementedError()
 
 
 def _init_simulation(

{eflips_depot-3.2.3 → eflips_depot-3.2.5}/eflips/depot/api/private/smart_charging.py

@@ -113,15 +113,20 @@ def optimize_charging_events_even(charging_events: List[Event]) -> None:
 
         # 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_factor = (total_occupancy / mean_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
+        power_scaling_vector = (
+            (mean_power * charging_factor) - mean_power
+        ) * -1  # How much to shift the power draw
+        if min(power_scaling_vector) < -mean_power:
+            power_scaling_vector /= min(power_scaling_vector) / -mean_power
+        optimized_power = params_for_event["charging_allowed"] * (
+            power_scaling_vector + mean_power
         )
 
         # Cap it at the peak power
@@ -149,11 +154,71 @@ def optimize_charging_events_even(charging_events: List[Event]) -> None:
         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
-        )
+
+        if False:
+            # Some plots for only this charging event
+            from matplotlib import pyplot as plt
+
+            valid_charging_indices = np.where(
+                params_for_event["charging_allowed"] == 1
+            )[0]
+
+            fig, axs = plt.subplots(3, 1, sharex=True)
+            axs[0].axhline(mean_power, color="red", linestyle="--", label="Mean power")
+            axs[0].plot(
+                total_time[valid_charging_indices],
+                params_for_event["power_draw"][valid_charging_indices],
+                label="Original power draw",
+            )
+            axs[0].plot(
+                total_time[valid_charging_indices],
+                optimized_power[valid_charging_indices],
+                label="Optimized power draw",
+            )
+            axs[0].plot(
+                total_time[valid_charging_indices],
+                optimized_power_capped[valid_charging_indices],
+                label="Optimized power draw capped",
+            )
+            axs[0].set_xlabel("Time")
+            axs[0].legend()
+
+            axs[1].plot(
+                total_time[valid_charging_indices],
+                np.cumsum(params_for_event["power_draw"][valid_charging_indices])
+                / 3600,
+                label="Original energy transferred",
+            )
+            axs[1].plot(
+                total_time[valid_charging_indices],
+                np.cumsum(optimized_power[valid_charging_indices]) / 3600,
+                label="Optimized energy transferred",
+            )
+            axs[1].set_xlabel("Time")
+
+            axs[2].axhline(
+                mean_occupancy, color="red", linestyle="--", label="Mean occupancy"
+            )
+            axs[2].plot(
+                total_time[valid_charging_indices],
+                total_occupancy[valid_charging_indices],
+            )
+
+            mean_arr = np.ones_like(total_occupancy) * mean_occupancy
+            mean_cumsum = np.cumsum(mean_arr[valid_charging_indices])
+            total_cumsum = np.cumsum(total_occupancy[valid_charging_indices])
+            assert np.isclose(mean_cumsum[-1], total_cumsum[-1], atol=0.01)
+
+            axs[2].set_xlabel("Time")
+            plt.show()
+
+        if not np.isclose(
+            post_opt_energy, params_for_event["transferred_energy"], rtol=0.001
+        ):
+            # Scale the power draw to match the transferred energy
+            optimized_power = optimized_power * (
+                params_for_event["transferred_energy"] / post_opt_energy
+            )
 
         optimized_power2 = (
             params_for_event["charging_allowed"] * mean_power
@@ -169,57 +234,55 @@ def optimize_charging_events_even(charging_events: List[Event]) -> None:
     if False:
         from matplotlib import pyplot as plt
 
-        plt.subplot(3, 1, 1)
+        fig, axs = plt.subplots(3, 1, sharex=True)
         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")
+        axs[0].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")
+        axs[0].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)")
+        axs[0].plot(total_time, optimized_power2, label="Mean power draw")
+        axs[0].set_xlabel("Time")
+        axs[0].set_ylabel("Total power draw (kW)")
 
-        plt.axhline(
+        axs[0].axhline(
             y=max(total_power), color="blue", linestyle="--", label="Max power draw"
         )
-        plt.axhline(
+        axs[0].axhline(
             y=max(optimized_power),
             color="orange",
             linestyle="--",
             label="Max optimized power draw",
         )
-        plt.axhline(
+        axs[0].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")
+        axs[1].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")
+        axs[1].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")
+        axs[1].plot(total_time, optimized_energy2, label="Mean energy transferred")
+        axs[1].set_xlabel("Time")
+        axs[1].set_ylabel("Total energy transferred (kWh)")
+
+        axs[2].plot(total_time, total_occupancy)
+        axs[2].set_xlabel("Time")
+        axs[2].set_ylabel("Vehicle count")
         plt.show()
 
     # Finally, update the events in the database

{eflips_depot-3.2.3 → eflips_depot-3.2.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "eflips-depot"
-version = "3.2.3"
+version = "3.2.5"
 description = "Depot Simulation for eFLIPS"
 authors = ["Enrico Lauth <enrico.lauth@tu-berlin.de>",
     "Ludger Heide <ludger.heide@tu-berlin.de",