Adapt devices to config.

Signed-off-by: Bobby Noelte <b0661n0e17e@gmail.com>

Author: b0661

src/akkudoktoreos/devices/battery.py

@@ -3,8 +3,12 @@
 import numpy as np
 from pydantic import BaseModel, Field, field_validator
 
+from akkudoktoreos.devices.devicesabc import DeviceBase
+from akkudoktoreos.utils.logutil import get_logger
 from akkudoktoreos.utils.utils import NumpyEncoder
 
+logger = get_logger(__name__)
+
 
 def max_ladeleistung_w_field(default: Optional[float] = None) -> Optional[float]:
     return Field(
@@ -83,31 +87,86 @@ def convert_numpy(cls, field: Any) -> Any:
         return NumpyEncoder.convert_numpy(field)[0]
 
 
-class PVAkku:
-    def __init__(self, parameters: BaseAkkuParameters, hours: int = 24):
-        # Battery capacity in Wh
-        self.kapazitaet_wh = parameters.kapazitaet_wh
-        # Initial state of charge in Wh
-        self.start_soc_prozent = parameters.start_soc_prozent
-        self.soc_wh = (parameters.start_soc_prozent / 100) * parameters.kapazitaet_wh
-        self.hours = hours
+class PVAkku(DeviceBase):
+    def __init__(
+        self,
+        parameters: Optional[BaseAkkuParameters] = None,
+        hours: Optional[int] = 24,
+        provider_id: Optional[str] = None,
+    ):
+        # Configuration initialisation
+        self.provider_id = provider_id
+        self.prefix = "<invalid>"
+        if self.provider_id == "GenericBattery":
+            self.prefix = "battery"
+        elif self.provider_id == "GenericBEV":
+            self.prefix = "bev"
+        # Parameter initialisiation
+        self.parameters = parameters
+        if hours is None:
+            self.hours = self.total_hours
+        else:
+            self.hours = hours
+
+        self.initialised = False
+        # Run setup if parameters are given, otherwise setup() has to be called later when the config is initialised.
+        if self.parameters is not None:
+            self.setup()
+
+    def setup(self) -> None:
+        if self.initialised:
+            return
+        if self.provider_id is not None:
+            # Setup by configuration
+            # Battery capacity in Wh
+            self.kapazitaet_wh = getattr(self.config, f"{self.prefix}_capacity")
+            # Initial state of charge in Wh
+            self.start_soc_prozent = getattr(self.config, f"{self.prefix}_soc_start")
+            self.hours = self.total_hours
+            # Charge and discharge efficiency
+            self.lade_effizienz = getattr(self.config, f"{self.prefix}_charge_efficiency")
+            self.entlade_effizienz = getattr(self.config, f"{self.prefix}_discharge_efficiency")
+            self.max_ladeleistung_w = getattr(self.config, f"{self.prefix}_charge_power_max")
+            # Only assign for storage battery
+            if self.provider_id == "GenericBattery":
+                self.min_soc_prozent = getattr(self.config, f"{self.prefix}_soc_mint")
+            else:
+                self.min_soc_prozent = 0
+            self.max_soc_prozent = getattr(self.config, f"{self.prefix}_soc_mint")
+        elif self.parameters is not None:
+            # Setup by parameters
+            # Battery capacity in Wh
+            self.kapazitaet_wh = self.parameters.kapazitaet_wh
+            # Initial state of charge in Wh
+            self.start_soc_prozent = self.parameters.start_soc_prozent
+            # Charge and discharge efficiency
+            self.lade_effizienz = self.parameters.lade_effizienz
+            self.entlade_effizienz = self.parameters.entlade_effizienz
+            self.max_ladeleistung_w = self.parameters.max_ladeleistung_w
+            # Only assign for storage battery
+            self.min_soc_prozent = (
+                self.parameters.min_soc_prozent
+                if isinstance(self.parameters, PVAkkuParameters)
+                else 0
+            )
+            self.max_soc_prozent = self.parameters.max_soc_prozent
+        else:
+            error_msg = "Parameters and provider ID missing. Can't instantiate."
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+        # init
+        if self.max_ladeleistung_w is None:
+            self.max_ladeleistung_w = self.kapazitaet_wh
         self.discharge_array = np.full(self.hours, 1)
         self.charge_array = np.full(self.hours, 1)
-        # Charge and discharge efficiency
-        self.lade_effizienz = parameters.lade_effizienz
-        self.entlade_effizienz = parameters.entlade_effizienz
-        self.max_ladeleistung_w = (
-            parameters.max_ladeleistung_w if parameters.max_ladeleistung_w else self.kapazitaet_wh
-        )
-        # Only assign for storage battery
-        self.min_soc_prozent = (
-            parameters.min_soc_prozent if isinstance(parameters, PVAkkuParameters) else 0
-        )
-        self.max_soc_prozent = parameters.max_soc_prozent
-        # Calculate min and max SoC in Wh
+        # Calculate start, min and max SoC in Wh
+        self.soc_wh = (self.start_soc_prozent / 100) * self.kapazitaet_wh
         self.min_soc_wh = (self.min_soc_prozent / 100) * self.kapazitaet_wh
         self.max_soc_wh = (self.max_soc_prozent / 100) * self.kapazitaet_wh
 
+        self.initialised = True
+
     def to_dict(self) -> dict[str, Any]:
         return {
             "kapazitaet_wh": self.kapazitaet_wh,

src/akkudoktoreos/devices/generic.py

@@ -1,6 +1,13 @@
+from typing import Optional
+
 import numpy as np
 from pydantic import BaseModel, Field
 
+from akkudoktoreos.devices.devicesabc import DeviceBase
+from akkudoktoreos.utils.logutil import get_logger
+
+logger = get_logger(__name__)
+
 
 class HomeApplianceParameters(BaseModel):
     consumption_wh: int = Field(
@@ -13,21 +20,57 @@ class HomeApplianceParameters(BaseModel):
     )
 
 
-class HomeAppliance:
-    def __init__(self, parameters: HomeApplianceParameters, hours: int = 24):
-        self.hours = hours  # Total duration for which the planning is done
-        self.consumption_wh = (
-            parameters.consumption_wh
-        )  # Total energy consumption of the device in kWh
-        self.duration_h = parameters.duration_h  # Duration of use in hours
+class HomeAppliance(DeviceBase):
+    def __init__(
+        self,
+        parameters: Optional[HomeApplianceParameters] = None,
+        hours: Optional[int] = 24,
+        provider_id: Optional[str] = None,
+    ):
+        # Configuration initialisation
+        self.provider_id = provider_id
+        self.prefix = "<invalid>"
+        if self.provider_id == "GenericDishWasher":
+            self.prefix = "dishwasher"
+        # Parameter initialisiation
+        self.parameters = parameters
+        if hours is None:
+            self.hours = self.total_hours
+        else:
+            self.hours = hours
+
+        self.initialised = False
+        # Run setup if parameters are given, otherwise setup() has to be called later when the config is initialised.
+        if self.parameters is not None:
+            self.setup()
+
+    def setup(self) -> None:
+        if self.initialised:
+            return
+        if self.provider_id is not None:
+            # Setup by configuration
+            self.hours = self.total_hours
+            self.consumption_wh = getattr(self.config, f"{self.prefix}_consumption")
+            self.duration_h = getattr(self.config, f"{self.prefix}_duration")
+        elif self.parameters is not None:
+            # Setup by parameters
+            self.consumption_wh = (
+                self.parameters.consumption_wh
+            )  # Total energy consumption of the device in kWh
+            self.duration_h = self.parameters.duration_h  # Duration of use in hours
+        else:
+            error_msg = "Parameters and provider ID missing. Can't instantiate."
+            logger.error(error_msg)
+            raise ValueError(error_msg)
         self.load_curve = np.zeros(self.hours)  # Initialize the load curve with zeros
+        self.initialised = True
 
     def set_starting_time(self, start_hour: int, global_start_hour: int = 0) -> None:
         """Sets the start time of the device and generates the corresponding load curve.
 
         :param start_hour: The hour at which the device should start.
         """
-        self.reset()
+        self.reset_load_curve()
         # Check if the duration of use is within the available time frame
         if start_hour + self.duration_h > self.hours:
             raise ValueError("The duration of use exceeds the available time frame.")
@@ -40,7 +83,7 @@ def set_starting_time(self, start_hour: int, global_start_hour: int = 0) -> None
         # Set the power for the duration of use in the load curve array
         self.load_curve[start_hour : start_hour + self.duration_h] = power_per_hour
 
-    def reset(self) -> None:
+    def reset_load_curve(self) -> None:
         """Resets the load curve."""
         self.load_curve = np.zeros(self.hours)
 

src/akkudoktoreos/devices/inverter.py

@@ -1,19 +1,61 @@
+from typing import Optional
+
 from pydantic import BaseModel, Field
 
 from akkudoktoreos.devices.battery import PVAkku
+from akkudoktoreos.devices.devicesabc import DeviceBase
+from akkudoktoreos.utils.logutil import get_logger
+
+logger = get_logger(__name__)
 
 
 class WechselrichterParameters(BaseModel):
     max_leistung_wh: float = Field(default=10000, gt=0)
 
 
-class Wechselrichter:
-    def __init__(self, parameters: WechselrichterParameters, akku: PVAkku):
-        self.max_leistung_wh = (
-            parameters.max_leistung_wh  # Maximum power that the inverter can handle
-        )
+class Wechselrichter(DeviceBase):
+    def __init__(
+        self,
+        parameters: Optional[WechselrichterParameters] = None,
+        akku: Optional[PVAkku] = None,
+        provider_id: Optional[str] = None,
+    ):
+        # Configuration initialisation
+        self.provider_id = provider_id
+        self.prefix = "<invalid>"
+        if self.provider_id == "GenericInverter":
+            self.prefix = "inverter"
+        # Parameter initialisiation
+        self.parameters = parameters
+        if akku is None:
+            # For the moment raise exception
+            # TODO: Make akku configurable by config
+            error_msg = "Battery for PV inverter is mandatory."
+            logger.error(error_msg)
+            raise NotImplementedError(error_msg)
         self.akku = akku  # Connection to a battery object
 
+        self.initialised = False
+        # Run setup if parameters are given, otherwise setup() has to be called later when the config is initialised.
+        if self.parameters is not None:
+            self.setup()
+
+    def setup(self) -> None:
+        if self.initialised:
+            return
+        if self.provider_id is not None:
+            # Setup by configuration
+            self.max_leistung_wh = getattr(self.config, f"{self.prefix}_power_max")
+        elif self.parameters is not None:
+            # Setup by parameters
+            self.max_leistung_wh = (
+                self.parameters.max_leistung_wh  # Maximum power that the inverter can handle
+            )
+        else:
+            error_msg = "Parameters and provider ID missing. Can't instantiate."
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
     def energie_verarbeiten(
         self, erzeugung: float, verbrauch: float, hour: int
     ) -> tuple[float, float, float, float]: