eflips-depot 4.14.2__py3-none-any.whl → 4.15.0__py3-none-any.whl

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(
@@ -1381,10 +1397,11 @@ def auto_generate_depot_inplace(
                 for trip in rot.trips:
                     for stop_time in trip.stop_times:
                         to_delete.append(stop_time)
+                    for event in trip.events:
+                        to_delete.append(event)
                     to_delete.append(trip)
                 to_delete.append(rot)
 
-        # debugging
         for obj in to_delete:
             session.flush()
             session.delete(obj)
@@ -1392,12 +1409,48 @@ def auto_generate_depot_inplace(
 
         # Consumption simulation for rotations of this depot
 
-        consumption_results = generate_consumption_result(scenario)
-        simple_consumption_simulation(
-            scenario,
-            initialize_vehicles=True,
-            consumption_result=consumption_results,
+        # if the driving events are already in the database, we do not need to run the consumption simulation again
+        current_driving_trips = (
+            session.query(Event.trip_id)
+            .filter(
+                Event.scenario_id == scenario.id, Event.event_type == EventType.DRIVING
+            )
+            .all()
         )
+        current_trips = (
+            session.query(Trip.id).filter(Trip.scenario_id == scenario.id).all()
+        )
+
+        # if the two lists are identical, we can skip the consumption simulation
+        if set([t[0] for t in current_driving_trips]) != set(
+            [t[0] for t in current_trips]
+        ):
+            logger.info(
+                "Running eflips consumption simulation for depot layout generation since the driving events do not cover all trips"
+            )
+            driving_events_to_delete = (
+                session.query(Event)
+                .filter(
+                    Event.scenario_id == scenario.id,
+                    Event.event_type == EventType.DRIVING,
+                )
+                .all()
+            )
+            if len(driving_events_to_delete) > 0:
+                logger.info(
+                    "Deleting existing driving events before running consumption simulation"
+                )
+                for event in driving_events_to_delete:
+                    session.delete(event)
+                session.flush()
+
+            logger.warning("Starting eflips consumption sim")
+            consumption_results = generate_consumption_result(scenario)
+            simple_consumption_simulation(
+                scenario,
+                initialize_vehicles=True,
+                consumption_result=consumption_results,
+            )
 
         logger.info(f"Generating depot layout for station {station.name}")
         vt_capacities_for_station = depot_smallest_possible_size(
@@ -1460,9 +1513,9 @@ def generate_optimal_depot_layout(
     """
 
     with create_session(scenario, database_url) as (session, scenario):
-        # Delete all depot events
+        # Delete all non-Driving events
         session.query(Event).filter(
-            Event.scenario_id == scenario.id, Event.area_id.isnot(None)
+            Event.scenario_id == scenario.id, Event.event_type != EventType.DRIVING
         ).delete()
 
         if session.query(Depot).filter(Depot.scenario_id == scenario.id).count() != 0:
@@ -1486,9 +1539,7 @@ def generate_optimal_depot_layout(
         # Delete all vehicles and events, also disconnect the vehicles from the rotations
         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()
-        session.expire_all()
+
         for depot_wish in depot_config_wishes:
             if depot_wish.auto_generate is False:
                 continue

eflips/depot/api/private/depot.py

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

eflips/depot/api/private/results_to_database.py

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

eflips/depot/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/processes.py

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

{eflips_depot-4.14.2.dist-info → eflips_depot-4.15.0.dist-info}/METADATA

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

{eflips_depot-4.14.2.dist-info → eflips_depot-4.15.0.dist-info}/RECORD

@@ -1,13 +1,13 @@
 eflips/depot/__init__.py,sha256=FCVnYU7aSfR4BNCo722I1V3uU5336qr1tTt-zT6X4UI,1555
-eflips/depot/api/__init__.py,sha256=TDjYjf2h_oBwm3Wmcw1J1RQrV2xct7ETOMsgVZ6c30A,65406
+eflips/depot/api/__init__.py,sha256=nq5aHGTOIpDmvDfcGMlCH_jd97E0VZ28KVcT3XTwpbE,67539
 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/consumption.py,sha256=0wfI3ryfZS9qUqPbJP0okvwY2s6ogylw1PZFyAnCRf4,28915
-eflips/depot/api/private/depot.py,sha256=c4XsRN06PScy4Z4yocqrdvMntmgOZdbIxNT9uuN2lxA,56857
-eflips/depot/api/private/results_to_database.py,sha256=nvWb4jEM5JwPAhvAdiQ-qzxUSawfRNsYfv3twNUFcGs,27348
+eflips/depot/api/private/depot.py,sha256=Vx6mC5YynyQ5hEw9QeXAi84VSaYc3qVJAqE2dSfHGJI,59655
+eflips/depot/api/private/results_to_database.py,sha256=-8qXk8lRsMElm9pke6MWzCNUQKtrd59n4Ye2X8Ojw-M,29814
 eflips/depot/api/private/util.py,sha256=DasTkuGUhlBpY_BtTFWoxSNZU_CRyM3RqEDgO07Eks8,17990
 eflips/depot/configuration.py,sha256=Op3hlir-dEN7yHr0kTqbYANoCBKFWK6uKOv3NJl8w_w,35678
-eflips/depot/depot.py,sha256=yNsH7xPYKpplHP3OeznKRxmmkEYLRP9aoAc6hBS_6Ms,107421
+eflips/depot/depot.py,sha256=5NBw5bvOP2cplkRGZbKbG3SOA23F2Kw-UsabHubocPU,107555
 eflips/depot/evaluation.py,sha256=qqXyP4jA1zFcKuWhliQ6n25ZlGl9mJV-vtXf0yu8WN8,140842
 eflips/depot/filters.py,sha256=1aUK7czuhiATC3P3NN5oRtH1I-kN_-mp_-vkzyyBXn4,16089
 eflips/depot/input_epex_power_price.py,sha256=VPDC1zy-klQpveGIZ8941hL1P_jeNq3IHoLgFTsANig,5569
@@ -27,7 +27,7 @@ eflips/depot/layout_opt/settings.py,sha256=EUGCp4dAX22j2uF8sKqbi9a5iP8hb6QpP7t2N
 eflips/depot/layout_opt/template_creation.py,sha256=H4LoFjQfbPjTt9rGvapH2tEUWcQ56kPwDucq7t6YahU,9736
 eflips/depot/layout_opt/util.py,sha256=EYh7IN58ZjysmCFdSieQqIQ9goe1a_ZwARRHxOgjEQo,3780
 eflips/depot/plots.py,sha256=85xInZWfJIOVm03onvppgP5yLTgQeMn-1t5aoNdavyY,2509
-eflips/depot/processes.py,sha256=wVacSuHQnHwe2kN18h4014eN4xs2XEegy9vJdHZ7wzQ,58610
+eflips/depot/processes.py,sha256=n4p_TDvtCDdkagLyX8eJbFFxext3fpVTTfbrGsCO52o,59321
 eflips/depot/rating.py,sha256=audUASHExeWg5ugytPLlcy5QGiTiFucnZ6-v3REoO2g,16427
 eflips/depot/resources.py,sha256=0SuzN8qgMmCqa7oUEXVC_XE6pCUtxTsqOfCsaM9Oh3o,13568
 eflips/depot/settings_config.py,sha256=z7CqPdjd8QRlgZj0Zis-H13cL7LOiheRT4ctYCYGguc,2527
@@ -36,7 +36,7 @@ eflips/depot/simulation.py,sha256=ee0qTzOzG-8ybN36ie_NJallXfC7jUaS9JZvaYFziLs,10
 eflips/depot/smart_charging.py,sha256=C3BYqzn2-OYY4ipXm0ETtavbAM9QXZMYULBpVoChf0E,54311
 eflips/depot/standalone.py,sha256=8O01zEXghFG9zZBu0fUD0sXvbHQ-AXw6RB5M750a_sM,22419
 eflips/depot/validation.py,sha256=TIuY7cQtEJI4H2VVMSuY5IIVkacEEZ67weeMuY3NSAM,7097
-eflips_depot-4.14.2.dist-info/METADATA,sha256=UvewbAnnEpknimQuan3FpVOmSmBXAvXmFPtfSxZbUdI,5961
-eflips_depot-4.14.2.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-eflips_depot-4.14.2.dist-info/licenses/LICENSE.md,sha256=KB4XTk1fPHjtZCYDyPyreu6h1LVJVZXYg-5vePcWZAc,34143
-eflips_depot-4.14.2.dist-info/RECORD,,
+eflips_depot-4.15.0.dist-info/METADATA,sha256=QsUnXsbK3OWypgsK6H6gCsfv6eHkTV4upbF1X9ZAUhI,5961
+eflips_depot-4.15.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+eflips_depot-4.15.0.dist-info/licenses/LICENSE.md,sha256=KB4XTk1fPHjtZCYDyPyreu6h1LVJVZXYg-5vePcWZAc,34143
+eflips_depot-4.15.0.dist-info/RECORD,,