emhass 0.11.4__py3-none-any.whl → 0.15.5__py3-none-any.whl

emhass/optimization.py

@@ -1,26 +1,24 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
 import bz2
 import copy
 import logging
-import pathlib
+import os
 import pickle as cPickle
 from math import ceil
-from typing import Optional, Tuple
 
 import numpy as np
 import pandas as pd
 import pulp as plp
-from pulp import COIN_CMD, GLPK_CMD, PULP_CBC_CMD
+from pulp import COIN_CMD, GLPK_CMD, PULP_CBC_CMD, HiGHS
+
+from emhass import utils
 
 
 class Optimization:
     r"""
-    Optimize the deferrable load and battery energy dispatch problem using \ 
+    Optimize the deferrable load and battery energy dispatch problem using \
     the linear programming optimization technique. All equipement equations, \
     including the battery equations are hence transformed in a linear form.
-    
+
     This class methods are:
 
     - perform_optimization
@@ -28,9 +26,9 @@ class Optimization:
     - perform_perfect_forecast_optim
 
     - perform_dayahead_forecast_optim
-    
+
     - perform_naive_mpc_optim
-    
+
     """
 
     def __init__(
@@ -43,11 +41,11 @@ class Optimization:
         costfun: str,
         emhass_conf: dict,
         logger: logging.Logger,
-        opt_time_delta: Optional[int] = 24,
+        opt_time_delta: int | None = 24,
     ) -> None:
         r"""
         Define constructor for Optimization class.
-        
+
         :param retrieve_hass_conf: Configuration parameters used to retrieve data \
             from hass
         :type retrieve_hass_conf: dict
@@ -70,26 +68,31 @@ class Optimization:
             more than one day then the optimization will be peformed by chunks of \
             opt_time_delta periods, defaults to 24
         :type opt_time_delta: float, optional
-        
+
         """
         self.retrieve_hass_conf = retrieve_hass_conf
         self.optim_conf = optim_conf
         self.plant_conf = plant_conf
         self.freq = self.retrieve_hass_conf["optimization_time_step"]
         self.time_zone = self.retrieve_hass_conf["time_zone"]
-        self.timeStep = self.freq.seconds / 3600  # in hours
-        self.time_delta = pd.to_timedelta(
-            opt_time_delta, "hours"
-        )  # The period of optimization
-        self.var_PV = self.retrieve_hass_conf["sensor_power_photovoltaics"]
+        self.time_step = self.freq.seconds / 3600  # in hours
+        self.time_delta = pd.to_timedelta(opt_time_delta, "hours")  # The period of optimization
+        self.var_pv = self.retrieve_hass_conf["sensor_power_photovoltaics"]
         self.var_load = self.retrieve_hass_conf["sensor_power_load_no_var_loads"]
         self.var_load_new = self.var_load + "_positive"
         self.costfun = costfun
-        # self.emhass_conf = emhass_conf
+        self.emhass_conf = emhass_conf
         self.logger = logger
         self.var_load_cost = var_load_cost
         self.var_prod_price = var_prod_price
         self.optim_status = None
+        if "num_threads" in optim_conf.keys():
+            if optim_conf["num_threads"] == 0:
+                self.num_threads = int(os.cpu_count())
+            else:
+                self.num_threads = int(optim_conf["num_threads"])
+        else:
+            self.num_threads = int(os.cpu_count())
         if "lp_solver" in optim_conf.keys():
             self.lp_solver = optim_conf["lp_solver"]
         else:
@@ -109,32 +112,110 @@ class Optimization:
                 "lp_solver=COIN_CMD but lp_solver_path=empty, attempting to use lp_solver_path=/usr/bin/cbc"
             )
             self.lp_solver_path = "/usr/bin/cbc"
+        self.logger.debug(f"Initialized Optimization with retrieve_hass_conf: {retrieve_hass_conf}")
+        self.logger.debug(f"Optimization configuration: {optim_conf}")
+        self.logger.debug(f"Plant configuration: {plant_conf}")
+        self.logger.debug(
+            f"Solver configuration: lp_solver={self.lp_solver}, lp_solver_path={self.lp_solver_path}"
+        )
+        self.logger.debug(f"Number of threads: {self.num_threads}")
+
+    def _setup_stress_cost(self, set_i, cost_conf_key, max_power, var_name_prefix):
+        """
+        Generic setup for a stress cost (battery or inverter).
+        """
+        stress_unit_cost = self.plant_conf.get(cost_conf_key, 0)
+        active = stress_unit_cost > 0 and max_power > 0
+
+        stress_cost_vars = None
+        if active:
+            self.logger.debug(
+                f"Stress cost enabled for {var_name_prefix}. "
+                f"Unit Cost: {stress_unit_cost}/kWh at full load {max_power}W."
+            )
+            stress_cost_vars = {
+                i: plp.LpVariable(
+                    cat="Continuous",
+                    lowBound=0,
+                    name=f"{var_name_prefix}_stress_cost_{i}",
+                )
+                for i in set_i
+            }
+
+        return {
+            "active": active,
+            "vars": stress_cost_vars,
+            "unit_cost": stress_unit_cost,
+            "max_power": max_power,
+            # Defaults to 10 segments if not provided in config
+            "segments": self.plant_conf.get(f"{var_name_prefix}_stress_segments", 10),
+        }
+
+    def _build_stress_segments(self, max_power, stress_unit_cost, segments):
+        """
+        Generic builder for Piece-Wise Linear segments for a quadratic cost curve.
+        """
+        # Cost rate at nominal power (currency/hr)
+        max_cost_rate_hr = (max_power / 1000.0) * stress_unit_cost
+        max_cost_step = max_cost_rate_hr * self.time_step
+
+        x_points = np.linspace(0, max_power, segments + 1)
+        y_points = max_cost_step * (x_points / max_power) ** 2
+
+        seg_params = []
+        for k in range(segments):
+            x0, x1 = x_points[k], x_points[k + 1]
+            y0, y1 = y_points[k], y_points[k + 1]
+            slope = (y1 - y0) / (x1 - x0)
+            intercept = y0 - slope * x0
+            seg_params.append((k, slope, intercept))
+        return seg_params
+
+    def _add_stress_constraints(
+        self, constraints, set_i, power_var_func, stress_vars, seg_params, prefix
+    ):
+        """
+        Generic constraint adder.
+        :param power_var_func: A function(i) that returns the LpVariable or Expression
+                               representing the power to be penalized at index i.
+        """
+        for k, slope, intercept in seg_params:
+            for sign, suffix in ((+1, "pos"), (-1, "neg")):
+                for i in set_i:
+                    name = f"constraint_stress_pwl_{prefix}_{suffix}_{k}_{i}"
+                    constraints[name] = plp.LpConstraint(
+                        e=stress_vars[i] - (sign * slope * power_var_func(i) + intercept),
+                        sense=plp.LpConstraintGE,
+                        rhs=0,
+                    )
 
     def perform_optimization(
         self,
         data_opt: pd.DataFrame,
-        P_PV: np.array,
-        P_load: np.array,
+        p_pv: np.array,
+        p_load: np.array,
         unit_load_cost: np.array,
         unit_prod_price: np.array,
-        soc_init: Optional[float] = None,
-        soc_final: Optional[float] = None,
-        def_total_hours: Optional[list] = None,
-        def_start_timestep: Optional[list] = None,
-        def_end_timestep: Optional[list] = None,
-        debug: Optional[bool] = False,
+        soc_init: float | None = None,
+        soc_final: float | None = None,
+        def_total_hours: list | None = None,
+        def_total_timestep: list | None = None,
+        def_start_timestep: list | None = None,
+        def_end_timestep: list | None = None,
+        def_init_temp: list | None = None,
+        debug: bool | None = False,
     ) -> pd.DataFrame:
         r"""
         Perform the actual optimization using linear programming (LP).
-        
+
         :param data_opt: A DataFrame containing the input data. The results of the \
             optimization will be appended (decision variables, cost function values, etc)
         :type data_opt: pd.DataFrame
-        :param P_PV: The photovoltaic power values. This can be real historical \
+        :param p_pv: The photovoltaic power values. This can be real historical \
             values or forecasted values.
-        :type P_PV: numpy.array
-        :param P_load: The load power consumption values
-        :type P_load: np.array
+        :type p_pv: numpy.array
+        :param p_load: The load power consumption values
+        :type p_load: np.array
         :param unit_load_cost: The cost of power consumption for each unit of time. \
             This is the cost of the energy from the utility in a vector sampled \
             at the fixed freq value
@@ -148,10 +229,13 @@ class Optimization:
         :type soc_init: float
         :param soc_final: The final battery SOC for the optimization. This parameter \
             is optional, if not given soc_init = soc_final = soc_target from the configuration file.
-        :type soc_final: 
+        :type soc_final:
         :param def_total_hours: The functioning hours for this iteration for each deferrable load. \
             (For continuous deferrable loads: functioning hours at nominal power)
         :type def_total_hours: list
+        :param def_total_timestep: The functioning timesteps for this iteration for each deferrable load. \
+            (For continuous deferrable loads: functioning timesteps at nominal power)
+        :type def_total_timestep: list
         :param def_start_timestep: The timestep as from which each deferrable load is allowed to operate.
         :type def_start_timestep: list
         :param def_end_timestep: The timestep before which each deferrable load should operate.
@@ -173,202 +257,229 @@ class Optimization:
                     soc_final = soc_init
                 else:
                     soc_final = self.plant_conf["battery_target_state_of_charge"]
-        if def_total_hours is None:
+            self.logger.debug(
+                f"Battery usage enabled. Initial SOC: {soc_init}, Final SOC: {soc_final}"
+            )
+
+        # If def_total_timestep os set, bypass def_total_hours
+        if def_total_timestep is not None:
+            if def_total_hours is None:
+                def_total_hours = self.optim_conf["operating_hours_of_each_deferrable_load"]
+            def_total_hours = [0 if x != 0 else x for x in def_total_hours]
+        elif def_total_hours is None:
             def_total_hours = self.optim_conf["operating_hours_of_each_deferrable_load"]
+
         if def_start_timestep is None:
-            def_start_timestep = self.optim_conf[
-                "start_timesteps_of_each_deferrable_load"
-            ]
+            def_start_timestep = self.optim_conf["start_timesteps_of_each_deferrable_load"]
         if def_end_timestep is None:
             def_end_timestep = self.optim_conf["end_timesteps_of_each_deferrable_load"]
+
+        # Initialize deferrable initial temperatures if not provided
+        if def_init_temp is None:
+            def_init_temp = [None] * self.optim_conf["number_of_deferrable_loads"]
+
         type_self_conso = "bigm"  # maxmin
 
+        num_deferrable_loads = self.optim_conf["number_of_deferrable_loads"]
+
+        # Retrieve the minimum power for each deferrable load, defaulting to 0 if not provided
+        min_power_of_deferrable_loads = self.optim_conf.get(
+            "minimum_power_of_deferrable_loads", [0] * num_deferrable_loads
+        )
+        min_power_of_deferrable_loads = min_power_of_deferrable_loads + [0] * (
+            num_deferrable_loads - len(min_power_of_deferrable_loads)
+        )
+
+        def_total_hours = def_total_hours + [0] * (num_deferrable_loads - len(def_total_hours))
+        def_start_timestep = def_start_timestep + [0] * (
+            num_deferrable_loads - len(def_start_timestep)
+        )
+        def_end_timestep = def_end_timestep + [0] * (num_deferrable_loads - len(def_end_timestep))
+
         #### The LP problem using Pulp ####
         opt_model = plp.LpProblem("LP_Model", plp.LpMaximize)
 
         n = len(data_opt.index)
-        set_I = range(n)
-        M = 10e10
+        set_i = range(n)
+        M = 100000
 
         ## Add decision variables
-        P_grid_neg = {
+        p_grid_neg = {
             (i): plp.LpVariable(
                 cat="Continuous",
                 lowBound=-self.plant_conf["maximum_power_to_grid"],
                 upBound=0,
-                name="P_grid_neg{}".format(i),
+                name=f"P_grid_neg{i}",
             )
-            for i in set_I
+            for i in set_i
         }
-        P_grid_pos = {
+        p_grid_pos = {
             (i): plp.LpVariable(
                 cat="Continuous",
                 lowBound=0,
                 upBound=self.plant_conf["maximum_power_from_grid"],
-                name="P_grid_pos{}".format(i),
+                name=f"P_grid_pos{i}",
             )
-            for i in set_I
+            for i in set_i
         }
-        P_deferrable = []
-        P_def_bin1 = []
-        for k in range(self.optim_conf["number_of_deferrable_loads"]):
-            if type(self.optim_conf["nominal_power_of_deferrable_loads"][k]) == list:
-                upBound = np.max(
-                    self.optim_conf["nominal_power_of_deferrable_loads"][k]
-                )
+        p_deferrable = []
+        p_def_bin1 = []
+        for k in range(num_deferrable_loads):
+            if isinstance(self.optim_conf["nominal_power_of_deferrable_loads"][k], list):
+                up_bound = np.max(self.optim_conf["nominal_power_of_deferrable_loads"][k])
             else:
-                upBound = self.optim_conf["nominal_power_of_deferrable_loads"][k]
+                up_bound = self.optim_conf["nominal_power_of_deferrable_loads"][k]
             if self.optim_conf["treat_deferrable_load_as_semi_cont"][k]:
-                P_deferrable.append(
+                p_deferrable.append(
                     {
-                        (i): plp.LpVariable(
-                            cat="Continuous", name="P_deferrable{}_{}".format(k, i)
-                        )
-                        for i in set_I
+                        (i): plp.LpVariable(cat="Continuous", name=f"P_deferrable{k}_{i}")
+                        for i in set_i
                     }
                 )
             else:
-                P_deferrable.append(
+                p_deferrable.append(
                     {
                         (i): plp.LpVariable(
                             cat="Continuous",
                             lowBound=0,
-                            upBound=upBound,
-                            name="P_deferrable{}_{}".format(k, i),
+                            upBound=up_bound,
+                            name=f"P_deferrable{k}_{i}",
                         )
-                        for i in set_I
+                        for i in set_i
                     }
                 )
-            P_def_bin1.append(
-                {
-                    (i): plp.LpVariable(
-                        cat="Binary", name="P_def{}_bin1_{}".format(k, i)
-                    )
-                    for i in set_I
-                }
+            p_def_bin1.append(
+                {(i): plp.LpVariable(cat="Binary", name=f"P_def{k}_bin1_{i}") for i in set_i}
             )
-        P_def_start = []
-        P_def_bin2 = []
+        p_def_start = []
+        p_def_bin2 = []
         for k in range(self.optim_conf["number_of_deferrable_loads"]):
-            P_def_start.append(
-                {
-                    (i): plp.LpVariable(
-                        cat="Binary", name="P_def{}_start_{}".format(k, i)
-                    )
-                    for i in set_I
-                }
+            p_def_start.append(
+                {(i): plp.LpVariable(cat="Binary", name=f"P_def{k}_start_{i}") for i in set_i}
             )
-            P_def_bin2.append(
-                {
-                    (i): plp.LpVariable(
-                        cat="Binary", name="P_def{}_bin2_{}".format(k, i)
-                    )
-                    for i in set_I
-                }
+            p_def_bin2.append(
+                {(i): plp.LpVariable(cat="Binary", name=f"P_def{k}_bin2_{i}") for i in set_i}
             )
-        D = {(i): plp.LpVariable(cat="Binary", name="D_{}".format(i)) for i in set_I}
-        E = {(i): plp.LpVariable(cat="Binary", name="E_{}".format(i)) for i in set_I}
+        D = {(i): plp.LpVariable(cat="Binary", name=f"D_{i}") for i in set_i}
+        E = {(i): plp.LpVariable(cat="Binary", name=f"E_{i}") for i in set_i}
+
+        # Initialize stress configuration dictionaries
+        inv_stress_conf = None
+        batt_stress_conf = None
+
         if self.optim_conf["set_use_battery"]:
-            P_sto_pos = {
+            if not self.plant_conf["inverter_is_hybrid"]:
+                self.logger.debug(
+                    "Non-hybrid system detected. Using 'battery_charge_power_max' (%s W) "
+                    "as the effective charge limit. "
+                    "Any 'inverter_ac_input_max' setting is ignored to prevent default value conflicts.",
+                    self.plant_conf["battery_charge_power_max"],
+                )
+            p_sto_pos = {
                 (i): plp.LpVariable(
                     cat="Continuous",
                     lowBound=0,
                     upBound=self.plant_conf["battery_discharge_power_max"],
-                    name="P_sto_pos_{0}".format(i),
+                    name=f"P_sto_pos_{i}",
                 )
-                for i in set_I
+                for i in set_i
             }
-            P_sto_neg = {
+            p_sto_neg = {
                 (i): plp.LpVariable(
                     cat="Continuous",
-                    lowBound=-self.plant_conf["battery_charge_power_max"],
+                    lowBound=-np.abs(self.plant_conf["battery_charge_power_max"]),
                     upBound=0,
-                    name="P_sto_neg_{0}".format(i),
+                    name=f"P_sto_neg_{i}",
                 )
-                for i in set_I
+                for i in set_i
             }
+
+            # Setup Battery Stress Cost
+            # We determine max power for the stress calculation as the max of charge/discharge limits
+            p_batt_max = max(
+                self.plant_conf.get("battery_discharge_power_max", 0),
+                self.plant_conf.get("battery_charge_power_max", 0),
+            )
+            batt_stress_conf = self._setup_stress_cost(
+                set_i, "battery_stress_cost", p_batt_max, "battery"
+            )
+
         else:
-            P_sto_pos = {(i): i * 0 for i in set_I}
-            P_sto_neg = {(i): i * 0 for i in set_I}
+            p_sto_pos = {(i): i * 0 for i in set_i}
+            p_sto_neg = {(i): i * 0 for i in set_i}
 
         if self.costfun == "self-consumption":
-            SC = {
-                (i): plp.LpVariable(cat="Continuous", name="SC_{}".format(i))
-                for i in set_I
-            }
+            SC = {(i): plp.LpVariable(cat="Continuous", name=f"SC_{i}") for i in set_i}
+
         if self.plant_conf["inverter_is_hybrid"]:
-            P_hybrid_inverter = {
-                (i): plp.LpVariable(
-                    cat="Continuous", name="P_hybrid_inverter{}".format(i)
-                )
-                for i in set_I
+            p_hybrid_inverter = {
+                (i): plp.LpVariable(cat="Continuous", name=f"P_hybrid_inverter{i}") for i in set_i
             }
-        P_PV_curtailment = {
-            (i): plp.LpVariable(
-                cat="Continuous", lowBound=0, name="P_PV_curtailment{}".format(i)
+            # Setup Inverter Stress Cost
+            P_nom_inverter_max = max(
+                self.plant_conf.get("inverter_ac_output_max", 0),
+                self.plant_conf.get("inverter_ac_input_max", 0),
             )
-            for i in set_I
+            inv_stress_conf = self._setup_stress_cost(
+                set_i, "inverter_stress_cost", P_nom_inverter_max, "inv"
+            )
+
+        p_pv_curtailment = {
+            (i): plp.LpVariable(cat="Continuous", lowBound=0, name=f"P_PV_curtailment{i}")
+            for i in set_i
         }
 
         ## Define objective
-        P_def_sum = []
-        for i in set_I:
-            P_def_sum.append(
+        p_def_sum = []
+        for i in set_i:
+            p_def_sum.append(
                 plp.lpSum(
-                    P_deferrable[k][i]
-                    for k in range(self.optim_conf["number_of_deferrable_loads"])
+                    p_deferrable[k][i] for k in range(self.optim_conf["number_of_deferrable_loads"])
                 )
             )
         if self.costfun == "profit":
             if self.optim_conf["set_total_pv_sell"]:
                 objective = plp.lpSum(
                     -0.001
-                    * self.timeStep
+                    * self.time_step
                     * (
-                        unit_load_cost[i] * (P_load[i] + P_def_sum[i])
-                        + unit_prod_price[i] * P_grid_neg[i]
+                        unit_load_cost[i] * (p_load[i] + p_def_sum[i])
+                        + unit_prod_price[i] * p_grid_neg[i]
                     )
-                    for i in set_I
+                    for i in set_i
                 )
             else:
                 objective = plp.lpSum(
                     -0.001
-                    * self.timeStep
-                    * (
-                        unit_load_cost[i] * P_grid_pos[i]
-                        + unit_prod_price[i] * P_grid_neg[i]
-                    )
-                    for i in set_I
+                    * self.time_step
+                    * (unit_load_cost[i] * p_grid_pos[i] + unit_prod_price[i] * p_grid_neg[i])
+                    for i in set_i
                 )
         elif self.costfun == "cost":
             if self.optim_conf["set_total_pv_sell"]:
                 objective = plp.lpSum(
-                    -0.001
-                    * self.timeStep
-                    * unit_load_cost[i]
-                    * (P_load[i] + P_def_sum[i])
-                    for i in set_I
+                    -0.001 * self.time_step * unit_load_cost[i] * (p_load[i] + p_def_sum[i])
+                    for i in set_i
                 )
             else:
                 objective = plp.lpSum(
-                    -0.001 * self.timeStep * unit_load_cost[i] * P_grid_pos[i]
-                    for i in set_I
+                    -0.001 * self.time_step * unit_load_cost[i] * p_grid_pos[i] for i in set_i
                 )
         elif self.costfun == "self-consumption":
             if type_self_conso == "bigm":
                 bigm = 1e3
                 objective = plp.lpSum(
                     -0.001
-                    * self.timeStep
+                    * self.time_step
                     * (
-                        bigm * unit_load_cost[i] * P_grid_pos[i]
-                        + unit_prod_price[i] * P_grid_neg[i]
+                        bigm * unit_load_cost[i] * p_grid_pos[i]
+                        + unit_prod_price[i] * p_grid_neg[i]
                     )
-                    for i in set_I
+                    for i in set_i
                 )
             elif type_self_conso == "maxmin":
                 objective = plp.lpSum(
-                    0.001 * self.timeStep * unit_load_cost[i] * SC[i] for i in set_I
+                    0.001 * self.time_step * unit_load_cost[i] * SC[i] for i in set_i
                 )
             else:
                 self.logger.error("Not a valid option for type_self_conso parameter")
@@ -378,12 +489,12 @@ class Optimization:
         if self.optim_conf["set_use_battery"]:
             objective = objective + plp.lpSum(
                 -0.001
-                * self.timeStep
+                * self.time_step
                 * (
-                    self.optim_conf["weight_battery_discharge"] * P_sto_pos[i]
-                    + self.optim_conf["weight_battery_charge"] * P_sto_neg[i]
+                    self.optim_conf["weight_battery_discharge"] * p_sto_pos[i]
+                    - self.optim_conf["weight_battery_charge"] * p_sto_neg[i]
                 )
-                for i in set_I
+                for i in set_i
             )
 
         # Add term penalizing each startup where configured
@@ -398,178 +509,298 @@ class Optimization:
                 ):
                     objective = objective + plp.lpSum(
                         -0.001
-                        * self.timeStep
+                        * self.time_step
                         * self.optim_conf["set_deferrable_startup_penalty"][k]
-                        * P_def_start[k][i]
+                        * p_def_start[k][i]
                         * unit_load_cost[i]
                         * self.optim_conf["nominal_power_of_deferrable_loads"][k]
-                        for i in set_I
+                        for i in set_i
                     )
 
+        # Add the Hybrid Inverter Stress cost to objective
+        if inv_stress_conf and inv_stress_conf["active"]:
+            objective = objective - plp.lpSum(inv_stress_conf["vars"][i] for i in set_i)
+
+        # Add the Battery Stress cost to objective
+        if batt_stress_conf and batt_stress_conf["active"]:
+            # Sanity check logging
+            self.logger.debug("Adding battery stress cost to objective function")
+            objective = objective - plp.lpSum(batt_stress_conf["vars"][i] for i in set_i)
+
         opt_model.setObjective(objective)
 
         ## Setting constraints
         # The main constraint: power balance
         if self.plant_conf["inverter_is_hybrid"]:
             constraints = {
-                "constraint_main1_{}".format(i): plp.LpConstraint(
-                    e=P_hybrid_inverter[i]
-                    - P_def_sum[i]
-                    - P_load[i]
-                    + P_grid_neg[i]
-                    + P_grid_pos[i],
+                f"constraint_main1_{i}": plp.LpConstraint(
+                    e=p_hybrid_inverter[i]
+                    - p_def_sum[i]
+                    - p_load[i]
+                    + p_grid_neg[i]
+                    + p_grid_pos[i],
                     sense=plp.LpConstraintEQ,
                     rhs=0,
                 )
-                for i in set_I
+                for i in set_i
             }
         else:
             if self.plant_conf["compute_curtailment"]:
                 constraints = {
-                    "constraint_main2_{}".format(i): plp.LpConstraint(
-                        e=P_PV[i]
-                        - P_PV_curtailment[i]
-                        - P_def_sum[i]
-                        - P_load[i]
-                        + P_grid_neg[i]
-                        + P_grid_pos[i]
-                        + P_sto_pos[i]
-                        + P_sto_neg[i],
+                    f"constraint_main2_{i}": plp.LpConstraint(
+                        e=p_pv[i]
+                        - p_pv_curtailment[i]
+                        - p_def_sum[i]
+                        - p_load[i]
+                        + p_grid_neg[i]
+                        + p_grid_pos[i]
+                        + p_sto_pos[i]
+                        + p_sto_neg[i],
                         sense=plp.LpConstraintEQ,
                         rhs=0,
                     )
-                    for i in set_I
+                    for i in set_i
                 }
             else:
                 constraints = {
-                    "constraint_main3_{}".format(i): plp.LpConstraint(
-                        e=P_PV[i]
-                        - P_def_sum[i]
-                        - P_load[i]
-                        + P_grid_neg[i]
-                        + P_grid_pos[i]
-                        + P_sto_pos[i]
-                        + P_sto_neg[i],
+                    f"constraint_main3_{i}": plp.LpConstraint(
+                        e=p_pv[i]
+                        - p_def_sum[i]
+                        - p_load[i]
+                        + p_grid_neg[i]
+                        + p_grid_pos[i]
+                        + p_sto_pos[i]
+                        + p_sto_neg[i],
                         sense=plp.LpConstraintEQ,
                         rhs=0,
                     )
-                    for i in set_I
+                    for i in set_i
                 }
 
-        # Constraint for hybrid inverter and curtailment cases
-        if type(self.plant_conf["pv_module_model"]) == list:
-            P_nom_inverter = 0.0
-            for i in range(len(self.plant_conf["pv_inverter_model"])):
-                if type(self.plant_conf["pv_inverter_model"][i]) == str:
-                    cec_inverters = bz2.BZ2File(
-                        pathlib.Path(__file__).parent / "data/cec_inverters.pbz2", "rb"
-                    )
-                    cec_inverters = cPickle.load(cec_inverters)
-                    inverter = cec_inverters[self.plant_conf["pv_inverter_model"][i]]
-                    P_nom_inverter += inverter.Paco
-                else:
-                    P_nom_inverter += self.plant_conf["pv_inverter_model"][i]
-        else:
-            if type(self.plant_conf["pv_inverter_model"][i]) == str:
-                cec_inverters = bz2.BZ2File(
-                    pathlib.Path(__file__).parent / "data/cec_inverters.pbz2", "rb"
-                )
-                cec_inverters = cPickle.load(cec_inverters)
-                inverter = cec_inverters[self.plant_conf["pv_inverter_model"]]
-                P_nom_inverter = inverter.Paco
-            else:
-                P_nom_inverter = self.plant_conf["pv_inverter_model"]
+        # Implementation of the Quadratic Battery Stress Cost
+        # This applies regardless of whether the inverter is hybrid or not, as long as battery is used.
+        if batt_stress_conf and batt_stress_conf["active"]:
+            self.logger.debug("Applying battery stress constraints to LP model")
+            seg_params = self._build_stress_segments(
+                batt_stress_conf["max_power"],
+                batt_stress_conf["unit_cost"],
+                batt_stress_conf["segments"],
+            )
+            # For Battery, the power magnitude is p_sto_pos[i] - p_sto_neg[i]
+            # (Recall p_sto_neg is <= 0, so this sums the absolute values)
+            self._add_stress_constraints(
+                constraints,
+                set_i,
+                lambda i: p_sto_pos[i] - p_sto_neg[i],
+                batt_stress_conf["vars"],
+                seg_params,
+                "batt",
+            )
+
         if self.plant_conf["inverter_is_hybrid"]:
-            constraints.update(
-                {
-                    "constraint_hybrid_inverter1_{}".format(i): plp.LpConstraint(
-                        e=P_PV[i]
-                        - P_PV_curtailment[i]
-                        + P_sto_pos[i]
-                        + P_sto_neg[i]
-                        - P_nom_inverter,
-                        sense=plp.LpConstraintLE,
-                        rhs=0,
+            p_nom_inverter_output = self.plant_conf.get("inverter_ac_output_max", None)
+            p_nom_inverter_input = self.plant_conf.get("inverter_ac_input_max", None)
+
+            # Fallback to legacy pv_inverter_model for output power if new setting is not provided
+            if p_nom_inverter_output is None:
+                if "pv_inverter_model" in self.plant_conf:
+                    if isinstance(self.plant_conf["pv_inverter_model"], list):
+                        p_nom_inverter_output = 0.0
+                        for i in range(len(self.plant_conf["pv_inverter_model"])):
+                            if isinstance(self.plant_conf["pv_inverter_model"][i], str):
+                                cec_inverters = bz2.BZ2File(
+                                    self.emhass_conf["root_path"] / "data" / "cec_inverters.pbz2",
+                                    "rb",
+                                )
+                                cec_inverters = cPickle.load(cec_inverters)
+                                inverter = cec_inverters[self.plant_conf["pv_inverter_model"][i]]
+                                p_nom_inverter_output += inverter.Paco
+                            else:
+                                p_nom_inverter_output += self.plant_conf["pv_inverter_model"][i]
+                    else:
+                        if isinstance(self.plant_conf["pv_inverter_model"], str):
+                            cec_inverters = bz2.BZ2File(
+                                self.emhass_conf["root_path"] / "data" / "cec_inverters.pbz2",
+                                "rb",
+                            )
+                            cec_inverters = cPickle.load(cec_inverters)
+                            inverter = cec_inverters[self.plant_conf["pv_inverter_model"]]
+                            p_nom_inverter_output = inverter.Paco
+                        else:
+                            p_nom_inverter_output = self.plant_conf["pv_inverter_model"]
+
+            if p_nom_inverter_input is None:
+                p_nom_inverter_input = p_nom_inverter_output
+
+            # Get efficiency parameters, defaulting to 100%
+            eff_dc_ac = self.plant_conf.get("inverter_efficiency_dc_ac", 1.0)
+            eff_ac_dc = self.plant_conf.get("inverter_efficiency_ac_dc", 1.0)
+
+            # Calculate the maximum allowed DC power flows based on AC limits and efficiency.
+            p_dc_ac_max = p_nom_inverter_output / eff_dc_ac
+            p_ac_dc_max = p_nom_inverter_input * eff_ac_dc
+
+            # Define unidirectional DC power flow variables with the tight, calculated bounds.
+            p_dc_ac = {
+                (i): plp.LpVariable(
+                    cat="Continuous",
+                    lowBound=0,
+                    upBound=p_dc_ac_max,
+                    name=f"P_dc_ac_{i}",
+                )
+                for i in set_i
+            }
+            p_ac_dc = {
+                (i): plp.LpVariable(
+                    cat="Continuous",
+                    lowBound=0,
+                    upBound=p_ac_dc_max,
+                    name=f"P_ac_dc_{i}",
+                )
+                for i in set_i
+            }
+            # Binary variable to enforce unidirectional flow
+            is_dc_sourcing = {
+                (i): plp.LpVariable(cat="Binary", name=f"is_dc_sourcing_{i}") for i in set_i
+            }
+
+            # Define the core energy balance equations for each timestep
+            for i in set_i:
+                # The net DC power from PV and battery must equal the net DC flow of the inverter
+                # Conditionally include curtailment variable to avoid energy leaks when feature is disabled
+                if self.plant_conf["compute_curtailment"]:
+                    e_dc_balance = (p_pv[i] - p_pv_curtailment[i] + p_sto_pos[i] + p_sto_neg[i]) - (
+                        p_dc_ac[i] - p_ac_dc[i]
                     )
-                    for i in set_I
-                }
-            )
-            constraints.update(
-                {
-                    "constraint_hybrid_inverter2_{}".format(i): plp.LpConstraint(
-                        e=P_PV[i]
-                        - P_PV_curtailment[i]
-                        + P_sto_pos[i]
-                        + P_sto_neg[i]
-                        - P_hybrid_inverter[i],
-                        sense=plp.LpConstraintEQ,
-                        rhs=0,
+                else:
+                    e_dc_balance = (p_pv[i] + p_sto_pos[i] + p_sto_neg[i]) - (
+                        p_dc_ac[i] - p_ac_dc[i]
                     )
-                    for i in set_I
-                }
-            )
-        else:
-            if self.plant_conf["compute_curtailment"]:
+
                 constraints.update(
                     {
-                        "constraint_curtailment_{}".format(i): plp.LpConstraint(
-                            e=P_PV_curtailment[i] - max(P_PV[i], 0),
-                            sense=plp.LpConstraintLE,
+                        f"constraint_dc_bus_balance_{i}": plp.LpConstraint(
+                            e=e_dc_balance,
+                            sense=plp.LpConstraintEQ,
                             rhs=0,
                         )
-                        for i in set_I
                     }
                 )
 
-        # Two special constraints just for a self-consumption cost function
-        if self.costfun == "self-consumption":
-            if type_self_conso == "maxmin":  # maxmin linear problem
+                # The AC power is defined by the efficiency-adjusted DC flows
                 constraints.update(
                     {
-                        "constraint_selfcons_PV1_{}".format(i): plp.LpConstraint(
-                            e=SC[i] - P_PV[i], sense=plp.LpConstraintLE, rhs=0
+                        f"constraint_ac_bus_balance_{i}": plp.LpConstraint(
+                            e=p_hybrid_inverter[i]
+                            - ((p_dc_ac[i] * eff_dc_ac) - (p_ac_dc[i] / eff_ac_dc)),
+                            sense=plp.LpConstraintEQ,
+                            rhs=0,
                         )
-                        for i in set_I
                     }
                 )
+
+                # Use the binary variable to ensure only one direction is active at a time
                 constraints.update(
                     {
-                        "constraint_selfcons_PV2_{}".format(i): plp.LpConstraint(
-                            e=SC[i] - P_load[i] - P_def_sum[i],
+                        # If is_dc_sourcing = 1 (DC->AC is active), then p_ac_dc must be 0.
+                        f"constraint_enforce_ac_dc_zero_{i}": plp.LpConstraint(
+                            e=p_ac_dc[i] - (1 - is_dc_sourcing[i]) * p_ac_dc_max,
                             sense=plp.LpConstraintLE,
                             rhs=0,
-                        )
-                        for i in set_I
+                        ),
+                        # If is_dc_sourcing = 0 (AC->DC is active), then p_dc_ac must be 0.
+                        f"constraint_enforce_dc_ac_zero_{i}": plp.LpConstraint(
+                            e=p_dc_ac[i] - is_dc_sourcing[i] * p_dc_ac_max,
+                            sense=plp.LpConstraintLE,
+                            rhs=0,
+                        ),
                     }
                 )
 
+            # Implementation of the Quadratic Inverter Stress Cost
+            if inv_stress_conf and inv_stress_conf["active"]:
+                seg_params = self._build_stress_segments(
+                    inv_stress_conf["max_power"],
+                    inv_stress_conf["unit_cost"],
+                    inv_stress_conf["segments"],
+                )
+                # For Inverter, the variable is p_hybrid_inverter[i]
+                self._add_stress_constraints(
+                    constraints,
+                    set_i,
+                    lambda i: p_hybrid_inverter[i],
+                    inv_stress_conf["vars"],
+                    seg_params,
+                    "inv",
+                )
+
+        # Apply curtailment constraint if enabled, regardless of inverter type
+        if self.plant_conf["compute_curtailment"]:
+            constraints.update(
+                {
+                    f"constraint_curtailment_{i}": plp.LpConstraint(
+                        e=p_pv_curtailment[i] - max(p_pv[i], 0),
+                        sense=plp.LpConstraintLE,
+                        rhs=0,
+                    )
+                    for i in set_i
+                }
+            )
+
+        # Two special constraints just for a self-consumption cost function
+        if (
+            self.costfun == "self-consumption" and type_self_conso == "maxmin"
+        ):  # maxmin linear problem
+            constraints.update(
+                {
+                    f"constraint_selfcons_PV1_{i}": plp.LpConstraint(
+                        e=SC[i] - p_pv[i], sense=plp.LpConstraintLE, rhs=0
+                    )
+                    for i in set_i
+                }
+            )
+            constraints.update(
+                {
+                    f"constraint_selfcons_PV2_{i}": plp.LpConstraint(
+                        e=SC[i] - p_load[i] - p_def_sum[i],
+                        sense=plp.LpConstraintLE,
+                        rhs=0,
+                    )
+                    for i in set_i
+                }
+            )
+
         # Avoid injecting and consuming from grid at the same time
         constraints.update(
             {
-                "constraint_pgridpos_{}".format(i): plp.LpConstraint(
-                    e=P_grid_pos[i] - self.plant_conf["maximum_power_from_grid"] * D[i],
+                f"constraint_pgridpos_{i}": plp.LpConstraint(
+                    e=p_grid_pos[i] - self.plant_conf["maximum_power_from_grid"] * D[i],
                     sense=plp.LpConstraintLE,
                     rhs=0,
                 )
-                for i in set_I
+                for i in set_i
             }
         )
         constraints.update(
             {
-                "constraint_pgridneg_{}".format(i): plp.LpConstraint(
-                    e=-P_grid_neg[i]
-                    - self.plant_conf["maximum_power_to_grid"] * (1 - D[i]),
+                f"constraint_pgridneg_{i}": plp.LpConstraint(
+                    e=-p_grid_neg[i] - self.plant_conf["maximum_power_to_grid"] * (1 - D[i]),
                     sense=plp.LpConstraintLE,
                     rhs=0,
                 )
-                for i in set_I
+                for i in set_i
             }
         )
 
         # Treat deferrable loads constraints
         predicted_temps = {}
+        heating_demands = {}  # Store heating demand for thermal loads
         for k in range(self.optim_conf["number_of_deferrable_loads"]):
-            if type(self.optim_conf["nominal_power_of_deferrable_loads"][k]) == list:
+            self.logger.debug(f"Processing deferrable load {k}")
+            if isinstance(self.optim_conf["nominal_power_of_deferrable_loads"][k], list):
+                self.logger.debug(
+                    f"Load {k} is sequence-based. Sequence: {self.optim_conf['nominal_power_of_deferrable_loads'][k]}"
+                )
                 # Constraint for sequence of deferrable
                 # WARNING: This is experimental, formulation seems correct but feasibility problems.
                 # Probably uncomptabile with other constraints
@@ -584,8 +815,9 @@ class Optimization:
                     return matrix
 
                 matrix = create_matrix(power_sequence, n - sequence_length)
-                y = plp.LpVariable.dicts(
-                    f"y{k}", (i for i in range(len(matrix))), cat="Binary"
+                y = plp.LpVariable.dicts(f"y{k}", range(len(matrix)), cat="Binary")
+                self.logger.debug(
+                    f"Load {k}: Created binary variables for sequence placement: y = {list(y.keys())}"
                 )
                 constraints.update(
                     {
@@ -599,8 +831,7 @@ class Optimization:
                 constraints.update(
                     {
                         f"pdef{k}_sumconstraint_{i}": plp.LpConstraint(
-                            e=plp.lpSum(P_deferrable[k][i] for i in set_I)
-                            - np.sum(power_sequence),
+                            e=plp.lpSum(p_deferrable[k][i] for i in set_i) - np.sum(power_sequence),
                             sense=plp.LpConstraintEQ,
                             rhs=0,
                         )
@@ -609,141 +840,459 @@ class Optimization:
                 constraints.update(
                     {
                         f"pdef{k}_positive_constraint_{i}": plp.LpConstraint(
-                            e=P_deferrable[k][i], sense=plp.LpConstraintGE, rhs=0
+                            e=p_deferrable[k][i], sense=plp.LpConstraintGE, rhs=0
                         )
-                        for i in set_I
+                        for i in set_i
                     }
                 )
                 for num, mat in enumerate(matrix):
                     constraints.update(
                         {
                             f"pdef{k}_value_constraint_{num}_{i}": plp.LpConstraint(
-                                e=P_deferrable[k][i] - mat[i] * y[num],
+                                e=p_deferrable[k][i] - mat[i] * y[num],
                                 sense=plp.LpConstraintEQ,
                                 rhs=0,
                             )
-                            for i in set_I
+                            for i in set_i
                         }
                     )
+                self.logger.debug(f"Load {k}: Sequence-based constraints set.")
+
+            # Thermal deferrable load logic first
+            elif (
+                "def_load_config" in self.optim_conf.keys()
+                and len(self.optim_conf["def_load_config"]) > k
+                and "thermal_config" in self.optim_conf["def_load_config"][k]
+            ):
+                self.logger.debug(f"Load {k} is a thermal deferrable load.")
+                def_load_config = self.optim_conf["def_load_config"][k]
+                if def_load_config and "thermal_config" in def_load_config:
+                    hc = def_load_config["thermal_config"]
 
-            elif "def_load_config" in self.optim_conf.keys():
-                if "thermal_config" in self.optim_conf["def_load_config"][k]:
-                    # Special case of a thermal deferrable load
-                    def_load_config = self.optim_conf["def_load_config"][k]
-                    if def_load_config and "thermal_config" in def_load_config:
-                        hc = def_load_config["thermal_config"]
+                    # Use passed runtime value (def_init_temp) if available, else config
+                    if def_init_temp[k] is not None:
+                        start_temperature = def_init_temp[k]
+                    else:
                         start_temperature = hc["start_temperature"]
-                        cooling_constant = hc["cooling_constant"]
-                        heating_rate = hc["heating_rate"]
-                        overshoot_temperature = hc["overshoot_temperature"]
-                        outdoor_temperature_forecast = data_opt[
-                            "outdoor_temperature_forecast"
-                        ]
-                        desired_temperatures = hc["desired_temperatures"]
-                        sense = hc.get("sense", "heat")
-                        predicted_temp = [start_temperature]
-                        for I in set_I:
-                            if I == 0:
-                                continue
-                            predicted_temp.append(
-                                predicted_temp[I - 1]
-                                + (
-                                    P_deferrable[k][I - 1]
-                                    * (
-                                        heating_rate
-                                        * self.timeStep
-                                        / self.optim_conf[
-                                            "nominal_power_of_deferrable_loads"
-                                        ][k]
-                                    )
+
+                    cooling_constant = hc["cooling_constant"]
+                    heating_rate = hc["heating_rate"]
+                    overshoot_temperature = hc.get("overshoot_temperature", None)
+                    outdoor_temperature_forecast = data_opt["outdoor_temperature_forecast"]
+                    # Support for both single desired temperature (legacy) and min/max range (new)
+                    desired_temperatures = hc.get("desired_temperatures", [])
+                    min_temperatures = hc.get("min_temperatures", [])
+                    max_temperatures = hc.get("max_temperatures", [])
+                    sense = hc.get("sense", "heat")
+                    sense_coeff = 1 if sense == "heat" else -1
+
+                    self.logger.debug(
+                        "Load %s: Thermal parameters: start_temperature=%s, cooling_constant=%s, heating_rate=%s",
+                        k,
+                        start_temperature,
+                        cooling_constant,
+                        heating_rate,
+                    )
+
+                    predicted_temp = [start_temperature]
+                    for index in set_i:
+                        if index == 0:
+                            continue
+
+                        predicted_temp.append(
+                            predicted_temp[index - 1]
+                            + (
+                                p_deferrable[k][index - 1]
+                                * (
+                                    heating_rate
+                                    * self.time_step
+                                    / self.optim_conf["nominal_power_of_deferrable_loads"][k]
                                 )
-                                - (
-                                    cooling_constant
-                                    * (
-                                        predicted_temp[I - 1]
-                                        - outdoor_temperature_forecast[I - 1]
-                                    )
+                            )
+                            - (
+                                cooling_constant
+                                * self.time_step
+                                * (
+                                    predicted_temp[index - 1]
+                                    - outdoor_temperature_forecast.iloc[index - 1]
                                 )
                             )
-                            if (
-                                len(desired_temperatures) > I
-                                and desired_temperatures[I]
-                            ):
+                        )
+
+                        # Constraint Logic: Comfort Range (Min/Max)
+                        # If min/max temps are provided, we enforce them.
+                        # This avoids the "penalty" method and ensures feasibility within a range.
+                        if len(min_temperatures) > index and min_temperatures[index] is not None:
+                            constraints.update(
+                                {
+                                    f"constraint_defload{k}_min_temp_{index}": plp.LpConstraint(
+                                        e=predicted_temp[index],
+                                        sense=plp.LpConstraintGE,
+                                        rhs=min_temperatures[index],
+                                    )
+                                }
+                            )
+
+                        if len(max_temperatures) > index and max_temperatures[index] is not None:
+                            constraints.update(
+                                {
+                                    f"constraint_defload{k}_max_temp_{index}": plp.LpConstraint(
+                                        e=predicted_temp[index],
+                                        sense=plp.LpConstraintLE,
+                                        rhs=max_temperatures[index],
+                                    )
+                                }
+                            )
+
+                        # Legacy "Overshoot" logic (Keep for backward compatibility)
+                        # Only added if desired_temperatures is present AND overshoot_temperature is defined
+                        if desired_temperatures and overshoot_temperature is not None:
+                            is_overshoot = plp.LpVariable(f"defload_{k}_overshoot_{index}")
+                            constraints.update(
+                                {
+                                    f"constraint_defload{k}_overshoot_{index}_1": plp.LpConstraint(
+                                        e=predicted_temp[index]
+                                        - overshoot_temperature
+                                        - (100 * sense_coeff * is_overshoot),
+                                        sense=plp.LpConstraintLE
+                                        if sense == "heat"
+                                        else plp.LpConstraintGE,
+                                        rhs=0,
+                                    ),
+                                    f"constraint_defload{k}_overshoot_{index}_2": plp.LpConstraint(
+                                        e=predicted_temp[index]
+                                        - overshoot_temperature
+                                        + (100 * sense_coeff * (1 - is_overshoot)),
+                                        sense=plp.LpConstraintGE
+                                        if sense == "heat"
+                                        else plp.LpConstraintLE,
+                                        rhs=0,
+                                    ),
+                                    f"constraint_defload{k}_overshoot_temp_{index}": plp.LpConstraint(
+                                        e=is_overshoot + p_def_bin2[k][index - 1],
+                                        sense=plp.LpConstraintLE,
+                                        rhs=1,
+                                    ),
+                                }
+                            )
+
+                            if len(desired_temperatures) > index and desired_temperatures[index]:
+                                penalty_factor = hc.get("penalty_factor", 10)
+                                if penalty_factor < 0:
+                                    raise ValueError(
+                                        "penalty_factor must be positive, otherwise the problem will become unsolvable"
+                                    )
+                                penalty_value = (
+                                    (predicted_temp[index] - desired_temperatures[index])
+                                    * penalty_factor
+                                    * sense_coeff
+                                )
+                                penalty_var = plp.LpVariable(
+                                    f"defload_{k}_thermal_penalty_{index}",
+                                    cat="Continuous",
+                                    upBound=0,
+                                )
                                 constraints.update(
                                     {
-                                        "constraint_defload{}_temperature_{}".format(
-                                            k, I
-                                        ): plp.LpConstraint(
-                                            e=predicted_temp[I],
-                                            sense=plp.LpConstraintGE
-                                            if sense == "heat"
-                                            else plp.LpConstraintLE,
-                                            rhs=desired_temperatures[I],
+                                        f"constraint_defload{k}_penalty_{index}": plp.LpConstraint(
+                                            e=penalty_var - penalty_value,
+                                            sense=plp.LpConstraintLE,
+                                            rhs=0,
                                         )
                                     }
                                 )
+                                opt_model.setObjective(opt_model.objective + penalty_var)
+
+                    # Only enforce semi-continuous if configured to do so
+                    if self.optim_conf["treat_deferrable_load_as_semi_cont"][k]:
                         constraints.update(
                             {
-                                "constraint_defload{}_overshoot_temp_{}".format(
-                                    k, I
-                                ): plp.LpConstraint(
-                                    e=predicted_temp[I],
-                                    sense=plp.LpConstraintLE
-                                    if sense == "heat"
-                                    else plp.LpConstraintGE,
-                                    rhs=overshoot_temperature,
+                                f"constraint_thermal_semicont_{k}_{i}": plp.LpConstraint(
+                                    e=p_deferrable[k][i]
+                                    - (
+                                        p_def_bin2[k][i]
+                                        * self.optim_conf["nominal_power_of_deferrable_loads"][k]
+                                    ),
+                                    sense=plp.LpConstraintEQ,
+                                    rhs=0,
                                 )
-                                for I in set_I
+                                for i in set_i
                             }
                         )
-                        predicted_temps[k] = predicted_temp
 
-            else:
-                if def_total_hours[k] > 0:
-                    # Total time of deferrable load
+                    predicted_temps[k] = predicted_temp
+                    self.logger.debug(f"Load {k}: Thermal constraints set.")
+
+            # Thermal battery load logic
+            elif (
+                "def_load_config" in self.optim_conf.keys()
+                and len(self.optim_conf["def_load_config"]) > k
+                and "thermal_battery" in self.optim_conf["def_load_config"][k]
+            ):
+                self.logger.debug(f"Load {k} is a thermal battery load.")
+                def_load_config = self.optim_conf["def_load_config"][k]
+                if def_load_config and "thermal_battery" in def_load_config:
+                    hc = def_load_config["thermal_battery"]
+
+                    start_temperature = hc["start_temperature"]
+
+                    supply_temperature = hc["supply_temperature"]  # heatpump supply temperature °C
+                    volume = hc["volume"]  # volume of the thermal battery m3
+                    outdoor_temperature_forecast = data_opt["outdoor_temperature_forecast"]
+
+                    min_temperatures = hc[
+                        "min_temperatures"
+                    ]  # list of lower bounds per timestep °C
+                    max_temperatures = hc[
+                        "max_temperatures"
+                    ]  # list of upper bounds per timestep °C
+
+                    # Validate that temperature lists are not empty
+                    if not min_temperatures:
+                        raise ValueError(
+                            f"Load {k}: thermal_battery requires non-empty 'min_temperatures' list"
+                        )
+                    if not max_temperatures:
+                        raise ValueError(
+                            f"Load {k}: thermal_battery requires non-empty 'max_temperatures' list"
+                        )
+
+                    p_concr = 2400  # Density of concrete kg/m3
+                    c_concr = 0.88  # Heat capacity of concrete kJ/kg*K
+                    loss = 0.045  # Temperature loss per time period (+/-) kW
+                    conversion = 3600 / (p_concr * c_concr * volume)  # °C per kWh
+
+                    self.logger.debug(
+                        "Load %s: Thermal battery parameters: start_temperature=%s, supply_temperature=%s, volume=%s, min_temperatures=%s, max_temperatures=%s",
+                        k,
+                        start_temperature,
+                        supply_temperature,
+                        volume,
+                        min_temperatures[0],
+                        max_temperatures[0],
+                    )
+
+                    heatpump_cops = utils.calculate_cop_heatpump(
+                        supply_temperature=supply_temperature,
+                        carnot_efficiency=hc.get("carnot_efficiency", 0.4),
+                        outdoor_temperature_forecast=outdoor_temperature_forecast,
+                    )
+                    thermal_losses = utils.calculate_thermal_loss_signed(
+                        outdoor_temperature_forecast=outdoor_temperature_forecast,
+                        indoor_temperature=start_temperature,
+                        base_loss=loss,
+                    )
+
+                    # Auto-detect heating demand calculation method
+                    # Use physics-based if core parameters are provided
+                    if all(
+                        key in hc
+                        for key in [
+                            "u_value",
+                            "envelope_area",
+                            "ventilation_rate",
+                            "heated_volume",
+                        ]
+                    ):
+                        # Physics-based method (more accurate)
+                        # Default indoor_target_temperature to the first min_temperature if not specified
+                        # This represents maintaining the lower comfort bound
+                        indoor_target_temp = hc.get(
+                            "indoor_target_temperature",
+                            min_temperatures[0] if min_temperatures else 20.0,
+                        )
+
+                        # Extract optional solar gain parameters
+                        window_area = hc.get("window_area", None)
+                        shgc = hc.get("shgc", 0.6)  # Default SHGC for modern double-glazed windows
+
+                        # Check if GHI (Global Horizontal Irradiance) data is available
+                        solar_irradiance = None
+                        if "ghi" in data_opt.columns and window_area is not None:
+                            solar_irradiance = data_opt["ghi"]
+
+                        heating_demand = utils.calculate_heating_demand_physics(
+                            u_value=hc["u_value"],
+                            envelope_area=hc["envelope_area"],
+                            ventilation_rate=hc["ventilation_rate"],
+                            heated_volume=hc["heated_volume"],
+                            indoor_target_temperature=indoor_target_temp,
+                            outdoor_temperature_forecast=outdoor_temperature_forecast,
+                            optimization_time_step=int(self.freq.total_seconds() / 60),
+                            solar_irradiance_forecast=solar_irradiance,
+                            window_area=window_area,
+                            shgc=shgc,
+                        )
+
+                        # Log with solar gains info if applicable
+                        if solar_irradiance is not None:
+                            self.logger.debug(
+                                "Load %s: Using physics-based heating demand with solar gains "
+                                "(u_value=%.2f, envelope_area=%.1f, ventilation_rate=%.2f, heated_volume=%.1f, "
+                                "indoor_target_temp=%.1f%s, window_area=%.1f, shgc=%.2f)",
+                                k,
+                                hc["u_value"],
+                                hc["envelope_area"],
+                                hc["ventilation_rate"],
+                                hc["heated_volume"],
+                                indoor_target_temp,
+                                " (defaulted to min_temp)"
+                                if "indoor_target_temperature" not in hc
+                                else "",
+                                window_area,
+                                shgc,
+                            )
+                        else:
+                            self.logger.debug(
+                                "Load %s: Using physics-based heating demand calculation "
+                                "(u_value=%.2f, envelope_area=%.1f, ventilation_rate=%.2f, heated_volume=%.1f, "
+                                "indoor_target_temp=%.1f%s)",
+                                k,
+                                hc["u_value"],
+                                hc["envelope_area"],
+                                hc["ventilation_rate"],
+                                hc["heated_volume"],
+                                indoor_target_temp,
+                                " (defaulted to min_temp)"
+                                if "indoor_target_temperature" not in hc
+                                else "",
+                            )
+                    else:
+                        # HDD method (backward compatible) with configurable parameters
+                        base_temperature = hc.get("base_temperature", 18.0)
+                        annual_reference_hdd = hc.get("annual_reference_hdd", 3000.0)
+                        heating_demand = utils.calculate_heating_demand(
+                            specific_heating_demand=hc["specific_heating_demand"],
+                            floor_area=hc["area"],
+                            outdoor_temperature_forecast=outdoor_temperature_forecast,
+                            base_temperature=base_temperature,
+                            annual_reference_hdd=annual_reference_hdd,
+                            optimization_time_step=int(self.freq.total_seconds() / 60),
+                        )
+                        self.logger.debug(
+                            "Load %s: Using HDD heating demand calculation (specific_heating_demand=%.1f, area=%.1f, base_temperature=%.1f, annual_reference_hdd=%.1f)",
+                            k,
+                            hc["specific_heating_demand"],
+                            hc["area"],
+                            base_temperature,
+                            annual_reference_hdd,
+                        )
+
+                    # Thermal battery state transition (Langer & Volling 2020, Eq B.11-B.15)
+                    # Store heating demand for this thermal battery load
+                    heating_demands[k] = heating_demand
+
+                    predicted_temp_thermal = [start_temperature]
+                    for index in set_i:
+                        if index == 0:
+                            continue
+
+                        # Equation B.11: T(h+1) = T(h) + conv * (COP*P - demand - loss)
+                        # where P is in kW, but emhass variables are in W, so divide by 1000
+                        predicted_temp_thermal.append(
+                            predicted_temp_thermal[index - 1]
+                            + conversion
+                            * (
+                                heatpump_cops[index - 1]
+                                * p_deferrable[k][index - 1]
+                                / 1000
+                                * self.time_step
+                                - heating_demand[index - 1]
+                                - thermal_losses[index - 1]
+                            )
+                        )
+
+                        # Equation B.15: Comfort range constraints
+                        # Support per-timestep temperature bounds (aligned with thermal_config)
+                        if len(min_temperatures) > index and min_temperatures[index] is not None:
+                            constraints.update(
+                                {
+                                    f"constraint_thermal_battery{k}_min_temp_{index}": plp.LpConstraint(
+                                        e=predicted_temp_thermal[index],
+                                        sense=plp.LpConstraintGE,
+                                        rhs=min_temperatures[index],
+                                    )
+                                }
+                            )
+
+                        if len(max_temperatures) > index and max_temperatures[index] is not None:
+                            constraints.update(
+                                {
+                                    f"constraint_thermal_battery{k}_max_temp_{index}": plp.LpConstraint(
+                                        e=predicted_temp_thermal[index],
+                                        sense=plp.LpConstraintLE,
+                                        rhs=max_temperatures[index],
+                                    )
+                                }
+                            )
+
+                    predicted_temps[k] = predicted_temp_thermal
+                    self.logger.debug(f"Load {k}: Thermal battery constraints set.")
+
+            # Standard/non-thermal deferrable load logic comes after thermal
+            elif (def_total_timestep and def_total_timestep[k] > 0) or (
+                len(def_total_hours) > k and def_total_hours[k] > 0
+            ):
+                self.logger.debug(f"Load {k} is standard/non-thermal.")
+                if def_total_timestep and def_total_timestep[k] > 0:
+                    self.logger.debug(
+                        f"Load {k}: Using total timesteps constraint: {def_total_timestep[k]}"
+                    )
+                    constraints.update(
+                        {
+                            f"constraint_defload{k}_energy": plp.LpConstraint(
+                                e=plp.lpSum(p_deferrable[k][i] * self.time_step for i in set_i),
+                                sense=plp.LpConstraintEQ,
+                                rhs=(self.time_step * def_total_timestep[k])
+                                * self.optim_conf["nominal_power_of_deferrable_loads"][k],
+                            )
+                        }
+                    )
+                else:
+                    self.logger.debug(
+                        f"Load {k}: Using total hours constraint: {def_total_hours[k]}"
+                    )
                     constraints.update(
                         {
-                            "constraint_defload{}_energy".format(k): plp.LpConstraint(
-                                e=plp.lpSum(
-                                    P_deferrable[k][i] * self.timeStep for i in set_I
-                                ),
+                            f"constraint_defload{k}_energy": plp.LpConstraint(
+                                e=plp.lpSum(p_deferrable[k][i] * self.time_step for i in set_i),
                                 sense=plp.LpConstraintEQ,
                                 rhs=def_total_hours[k]
-                                * self.optim_conf["nominal_power_of_deferrable_loads"][
-                                    k
-                                ],
+                                * self.optim_conf["nominal_power_of_deferrable_loads"][k],
                             )
                         }
                     )
+                self.logger.debug(f"Load {k}: Standard load constraints set.")
 
             # Ensure deferrable loads consume energy between def_start_timestep & def_end_timestep
             self.logger.debug(
-                "Deferrable load {}: Proposed optimization window: {} --> {}".format(
-                    k, def_start_timestep[k], def_end_timestep[k]
-                )
-            )
-            def_start, def_end, warning = Optimization.validate_def_timewindow(
-                def_start_timestep[k],
-                def_end_timestep[k],
-                ceil(def_total_hours[k] / self.timeStep),
-                n,
+                f"Deferrable load {k}: Proposed optimization window: {def_start_timestep[k]} --> {def_end_timestep[k]}"
             )
+            if def_total_timestep and def_total_timestep[k] > 0:
+                def_start, def_end, warning = Optimization.validate_def_timewindow(
+                    def_start_timestep[k],
+                    def_end_timestep[k],
+                    ceil(def_total_timestep[k]),
+                    n,
+                )
+            else:
+                def_start, def_end, warning = Optimization.validate_def_timewindow(
+                    def_start_timestep[k],
+                    def_end_timestep[k],
+                    ceil(def_total_hours[k] / self.time_step),
+                    n,
+                )
             if warning is not None:
-                self.logger.warning("Deferrable load {} : {}".format(k, warning))
+                self.logger.warning(f"Deferrable load {k} : {warning}")
             self.logger.debug(
-                "Deferrable load {}: Validated optimization window: {} --> {}".format(
-                    k, def_start, def_end
-                )
+                f"Deferrable load {k}: Validated optimization window: {def_start} --> {def_end}"
             )
             if def_start > 0:
                 constraints.update(
                     {
-                        "constraint_defload{}_start_timestep".format(
-                            k
-                        ): plp.LpConstraint(
+                        f"constraint_defload{k}_start_timestep": plp.LpConstraint(
                             e=plp.lpSum(
-                                P_deferrable[k][i] * self.timeStep
-                                for i in range(0, def_start)
+                                p_deferrable[k][i] * self.time_step for i in range(0, def_start)
                             ),
                             sense=plp.LpConstraintEQ,
                             rhs=0,
@@ -753,10 +1302,9 @@ class Optimization:
             if def_end > 0:
                 constraints.update(
                     {
-                        "constraint_defload{}_end_timestep".format(k): plp.LpConstraint(
+                        f"constraint_defload{k}_end_timestep": plp.LpConstraint(
                             e=plp.lpSum(
-                                P_deferrable[k][i] * self.timeStep
-                                for i in range(def_end, n)
+                                p_deferrable[k][i] * self.time_step for i in range(def_end, n)
                             ),
                             sense=plp.LpConstraintEQ,
                             rhs=0,
@@ -764,6 +1312,24 @@ class Optimization:
                     }
                 )
 
+            # Constraint for the minimum power of deferrable loads using the big-M method.
+            # This enforces: p_deferrable = 0 OR p_deferrable >= min_power.
+            if min_power_of_deferrable_loads[k] > 0:
+                self.logger.debug(
+                    f"Applying minimum power constraint for deferrable load {k}: {min_power_of_deferrable_loads[k]} W"
+                )
+                constraints.update(
+                    {
+                        f"constraint_pdef{k}_min_power_{i}": plp.LpConstraint(
+                            e=p_deferrable[k][i]
+                            - (min_power_of_deferrable_loads[k] * p_def_bin2[k][i]),
+                            sense=plp.LpConstraintGE,
+                            rhs=0,
+                        )
+                        for i in set_i
+                    }
+                )
+
             # Treat the number of starts for a deferrable load (new method considering current state)
             current_state = 0
             if (
@@ -771,162 +1337,149 @@ class Optimization:
                 and len(self.optim_conf["def_current_state"]) > k
             ):
                 current_state = 1 if self.optim_conf["def_current_state"][k] else 0
-            # P_deferrable < P_def_bin2 * 1 million
-            # P_deferrable must be zero if P_def_bin2 is zero
+            # p_deferrable < p_def_bin2 * 1 million
+            # p_deferrable must be zero if p_def_bin2 is zero
             constraints.update(
                 {
-                    "constraint_pdef{}_start1_{}".format(k, i): plp.LpConstraint(
-                        e=P_deferrable[k][i] - P_def_bin2[k][i] * M,
+                    f"constraint_pdef{k}_start1_{i}": plp.LpConstraint(
+                        e=p_deferrable[k][i] - p_def_bin2[k][i] * M,
                         sense=plp.LpConstraintLE,
                         rhs=0,
                     )
-                    for i in set_I
+                    for i in set_i
                 }
             )
-            # P_deferrable - P_def_bin2 <= 0
-            # P_def_bin2 must be zero if P_deferrable is zero
+            # p_deferrable - p_def_bin2 <= 0
+            # p_def_bin2 must be zero if p_deferrable is zero
             constraints.update(
                 {
-                    "constraint_pdef{}_start1a_{}".format(k, i): plp.LpConstraint(
-                        e=P_def_bin2[k][i] - P_deferrable[k][i],
+                    f"constraint_pdef{k}_start1a_{i}": plp.LpConstraint(
+                        e=p_def_bin2[k][i] - p_deferrable[k][i],
                         sense=plp.LpConstraintLE,
                         rhs=0,
                     )
-                    for i in set_I
+                    for i in set_i
                 }
             )
-            # P_def_start + P_def_bin2[i-1] >= P_def_bin2[i]
-            # If load is on this cycle (P_def_bin2[i] is 1) then P_def_start must be 1 OR P_def_bin2[i-1] must be 1
+            # p_def_start + p_def_bin2[i-1] >= p_def_bin2[i]
+            # If load is on this cycle (p_def_bin2[i] is 1) then p_def_start must be 1 OR p_def_bin2[i-1] must be 1
             # For first timestep, use current state if provided by caller.
             constraints.update(
                 {
-                    "constraint_pdef{}_start2_{}".format(k, i): plp.LpConstraint(
-                        e=P_def_start[k][i]
-                        - P_def_bin2[k][i]
-                        + (P_def_bin2[k][i - 1] if i - 1 >= 0 else current_state),
+                    f"constraint_pdef{k}_start2_{i}": plp.LpConstraint(
+                        e=p_def_start[k][i]
+                        - p_def_bin2[k][i]
+                        + (p_def_bin2[k][i - 1] if i - 1 >= 0 else current_state),
                         sense=plp.LpConstraintGE,
                         rhs=0,
                     )
-                    for i in set_I
+                    for i in set_i
                 }
             )
-            # P_def_bin2[i-1] + P_def_start <= 1
-            # If load started this cycle (P_def_start[i] is 1) then P_def_bin2[i-1] must be 0
+            # p_def_bin2[i-1] + p_def_start <= 1
+            # If load started this cycle (p_def_start[i] is 1) then p_def_bin2[i-1] must be 0
             constraints.update(
                 {
-                    "constraint_pdef{}_start3_{}".format(k, i): plp.LpConstraint(
-                        e=(P_def_bin2[k][i - 1] if i - 1 >= 0 else 0)
-                        + P_def_start[k][i],
+                    f"constraint_pdef{k}_start3_{i}": plp.LpConstraint(
+                        e=(p_def_bin2[k][i - 1] if i - 1 >= 0 else 0) + p_def_start[k][i],
                         sense=plp.LpConstraintLE,
                         rhs=1,
                     )
-                    for i in set_I
+                    for i in set_i
                 }
             )
 
             # Treat deferrable as a fixed value variable with just one startup
             if self.optim_conf["set_deferrable_load_single_constant"][k]:
-                # P_def_start[i] must be 1 for exactly 1 value of i
+                # p_def_start[i] must be 1 for exactly 1 value of i
                 constraints.update(
                     {
-                        "constraint_pdef{}_start4".format(k): plp.LpConstraint(
-                            e=plp.lpSum(P_def_start[k][i] for i in set_I),
+                        f"constraint_pdef{k}_start4": plp.LpConstraint(
+                            e=plp.lpSum(p_def_start[k][i] for i in set_i),
                             sense=plp.LpConstraintEQ,
                             rhs=1,
                         )
                     }
                 )
-                # P_def_bin2 must be 1 for exactly the correct number of timesteps.
-                constraints.update(
-                    {
-                        "constraint_pdef{}_start5".format(k): plp.LpConstraint(
-                            e=plp.lpSum(P_def_bin2[k][i] for i in set_I),
-                            sense=plp.LpConstraintEQ,
-                            rhs=def_total_hours[k] / self.timeStep,
-                        )
-                    }
-                )
+                # p_def_bin2 must be 1 for exactly the correct number of timesteps.
+                if def_total_timestep and def_total_timestep[k] > 0:
+                    constraints.update(
+                        {
+                            f"constraint_pdef{k}_start5": plp.LpConstraint(
+                                e=plp.lpSum(p_def_bin2[k][i] for i in set_i),
+                                sense=plp.LpConstraintEQ,
+                                rhs=def_total_timestep[k],
+                            )
+                        }
+                    )
+                else:
+                    constraints.update(
+                        {
+                            f"constraint_pdef{k}_start5": plp.LpConstraint(
+                                e=plp.lpSum(p_def_bin2[k][i] for i in set_i),
+                                sense=plp.LpConstraintEQ,
+                                rhs=def_total_hours[k] / self.time_step,
+                            )
+                        }
+                    )
 
             # Treat deferrable load as a semi-continuous variable
             if self.optim_conf["treat_deferrable_load_as_semi_cont"][k]:
                 constraints.update(
                     {
-                        "constraint_pdef{}_semicont1_{}".format(k, i): plp.LpConstraint(
-                            e=P_deferrable[k][i]
+                        f"constraint_pdef{k}_semicont1_{i}": plp.LpConstraint(
+                            e=p_deferrable[k][i]
                             - self.optim_conf["nominal_power_of_deferrable_loads"][k]
-                            * P_def_bin1[k][i],
+                            * p_def_bin1[k][i],
                             sense=plp.LpConstraintGE,
                             rhs=0,
                         )
-                        for i in set_I
+                        for i in set_i
                     }
                 )
                 constraints.update(
                     {
-                        "constraint_pdef{}_semicont2_{}".format(k, i): plp.LpConstraint(
-                            e=P_deferrable[k][i]
+                        f"constraint_pdef{k}_semicont2_{i}": plp.LpConstraint(
+                            e=p_deferrable[k][i]
                             - self.optim_conf["nominal_power_of_deferrable_loads"][k]
-                            * P_def_bin1[k][i],
+                            * p_def_bin1[k][i],
                             sense=plp.LpConstraintLE,
                             rhs=0,
                         )
-                        for i in set_I
+                        for i in set_i
                     }
                 )
 
-            # Treat the number of starts for a deferrable load (old method, kept here just in case)
-            # if self.optim_conf['set_deferrable_load_single_constant'][k]:
-            #     constraints.update({"constraint_pdef{}_start1_{}".format(k, i) :
-            #         plp.LpConstraint(
-            #             e=P_deferrable[k][i] - P_def_bin2[k][i]*M,
-            #             sense=plp.LpConstraintLE,
-            #             rhs=0)
-            #         for i in set_I})
-            #     constraints.update({"constraint_pdef{}_start2_{}".format(k, i):
-            #         plp.LpConstraint(
-            #             e=P_def_start[k][i] - P_def_bin2[k][i] + (P_def_bin2[k][i-1] if i-1 >= 0 else 0),
-            #             sense=plp.LpConstraintGE,
-            #             rhs=0)
-            #         for i in set_I})
-            #     constraints.update({"constraint_pdef{}_start3".format(k) :
-            #     plp.LpConstraint(
-            #         e = plp.lpSum(P_def_start[k][i] for i in set_I),
-            #         sense = plp.LpConstraintEQ,
-            #         rhs = 1)
-            #     })
-
         # The battery constraints
         if self.optim_conf["set_use_battery"]:
             # Optional constraints to avoid charging the battery from the grid
             if self.optim_conf["set_nocharge_from_grid"]:
                 constraints.update(
                     {
-                        "constraint_nocharge_from_grid_{}".format(i): plp.LpConstraint(
-                            e=P_sto_neg[i] + P_PV[i], sense=plp.LpConstraintGE, rhs=0
+                        f"constraint_nocharge_from_grid_{i}": plp.LpConstraint(
+                            e=p_sto_neg[i] + p_pv[i], sense=plp.LpConstraintGE, rhs=0
                         )
-                        for i in set_I
+                        for i in set_i
                     }
                 )
             # Optional constraints to avoid discharging the battery to the grid
             if self.optim_conf["set_nodischarge_to_grid"]:
                 constraints.update(
                     {
-                        "constraint_nodischarge_to_grid_{}".format(i): plp.LpConstraint(
-                            e=P_grid_neg[i] + P_PV[i], sense=plp.LpConstraintGE, rhs=0
+                        f"constraint_nodischarge_to_grid_{i}": plp.LpConstraint(
+                            e=p_grid_neg[i] + p_pv[i], sense=plp.LpConstraintGE, rhs=0
                         )
-                        for i in set_I
+                        for i in set_i
                     }
                 )
             # Limitation of power dynamics in power per unit of time
             if self.optim_conf["set_battery_dynamic"]:
                 constraints.update(
                     {
-                        "constraint_pos_batt_dynamic_max_{}".format(
-                            i
-                        ): plp.LpConstraint(
-                            e=P_sto_pos[i + 1] - P_sto_pos[i],
+                        f"constraint_pos_batt_dynamic_max_{i}": plp.LpConstraint(
+                            e=p_sto_pos[i + 1] - p_sto_pos[i],
                             sense=plp.LpConstraintLE,
-                            rhs=self.timeStep
+                            rhs=self.time_step
                             * self.optim_conf["battery_dynamic_max"]
                             * self.plant_conf["battery_discharge_power_max"],
                         )
@@ -935,12 +1488,10 @@ class Optimization:
                 )
                 constraints.update(
                     {
-                        "constraint_pos_batt_dynamic_min_{}".format(
-                            i
-                        ): plp.LpConstraint(
-                            e=P_sto_pos[i + 1] - P_sto_pos[i],
+                        f"constraint_pos_batt_dynamic_min_{i}": plp.LpConstraint(
+                            e=p_sto_pos[i + 1] - p_sto_pos[i],
                             sense=plp.LpConstraintGE,
-                            rhs=self.timeStep
+                            rhs=self.time_step
                             * self.optim_conf["battery_dynamic_min"]
                             * self.plant_conf["battery_discharge_power_max"],
                         )
@@ -949,12 +1500,10 @@ class Optimization:
                 )
                 constraints.update(
                     {
-                        "constraint_neg_batt_dynamic_max_{}".format(
-                            i
-                        ): plp.LpConstraint(
-                            e=P_sto_neg[i + 1] - P_sto_neg[i],
+                        f"constraint_neg_batt_dynamic_max_{i}": plp.LpConstraint(
+                            e=p_sto_neg[i + 1] - p_sto_neg[i],
                             sense=plp.LpConstraintLE,
-                            rhs=self.timeStep
+                            rhs=self.time_step
                             * self.optim_conf["battery_dynamic_max"]
                             * self.plant_conf["battery_charge_power_max"],
                         )
@@ -963,12 +1512,10 @@ class Optimization:
                 )
                 constraints.update(
                     {
-                        "constraint_neg_batt_dynamic_min_{}".format(
-                            i
-                        ): plp.LpConstraint(
-                            e=P_sto_neg[i + 1] - P_sto_neg[i],
+                        f"constraint_neg_batt_dynamic_min_{i}": plp.LpConstraint(
+                            e=p_sto_neg[i + 1] - p_sto_neg[i],
                             sense=plp.LpConstraintGE,
-                            rhs=self.timeStep
+                            rhs=self.time_step
                             * self.optim_conf["battery_dynamic_min"]
                             * self.plant_conf["battery_charge_power_max"],
                         )
@@ -978,106 +1525,98 @@ class Optimization:
             # Then the classic battery constraints
             constraints.update(
                 {
-                    "constraint_pstopos_{}".format(i): plp.LpConstraint(
-                        e=P_sto_pos[i]
+                    f"constraint_pstopos_{i}": plp.LpConstraint(
+                        e=p_sto_pos[i]
                         - self.plant_conf["battery_discharge_efficiency"]
                         * self.plant_conf["battery_discharge_power_max"]
                         * E[i],
                         sense=plp.LpConstraintLE,
                         rhs=0,
                     )
-                    for i in set_I
+                    for i in set_i
                 }
             )
             constraints.update(
                 {
-                    "constraint_pstoneg_{}".format(i): plp.LpConstraint(
-                        e=-P_sto_neg[i]
+                    f"constraint_pstoneg_{i}": plp.LpConstraint(
+                        e=-p_sto_neg[i]
                         - (1 / self.plant_conf["battery_charge_efficiency"])
                         * self.plant_conf["battery_charge_power_max"]
                         * (1 - E[i]),
                         sense=plp.LpConstraintLE,
                         rhs=0,
                     )
-                    for i in set_I
+                    for i in set_i
                 }
             )
             constraints.update(
                 {
-                    "constraint_socmax_{}".format(i): plp.LpConstraint(
+                    f"constraint_socmax_{i}": plp.LpConstraint(
                         e=-plp.lpSum(
-                            P_sto_pos[j]
-                            * (1 / self.plant_conf["battery_discharge_efficiency"])
-                            + self.plant_conf["battery_charge_efficiency"]
-                            * P_sto_neg[j]
+                            p_sto_pos[j] * (1 / self.plant_conf["battery_discharge_efficiency"])
+                            + self.plant_conf["battery_charge_efficiency"] * p_sto_neg[j]
                             for j in range(i)
                         ),
                         sense=plp.LpConstraintLE,
-                        rhs=(
-                            self.plant_conf["battery_nominal_energy_capacity"]
-                            / self.timeStep
-                        )
-                        * (
-                            self.plant_conf["battery_maximum_state_of_charge"]
-                            - soc_init
-                        ),
+                        rhs=(self.plant_conf["battery_nominal_energy_capacity"] / self.time_step)
+                        * (self.plant_conf["battery_maximum_state_of_charge"] - soc_init),
                     )
-                    for i in set_I
+                    for i in set_i
                 }
             )
             constraints.update(
                 {
-                    "constraint_socmin_{}".format(i): plp.LpConstraint(
+                    f"constraint_socmin_{i}": plp.LpConstraint(
                         e=plp.lpSum(
-                            P_sto_pos[j]
-                            * (1 / self.plant_conf["battery_discharge_efficiency"])
-                            + self.plant_conf["battery_charge_efficiency"]
-                            * P_sto_neg[j]
+                            p_sto_pos[j] * (1 / self.plant_conf["battery_discharge_efficiency"])
+                            + self.plant_conf["battery_charge_efficiency"] * p_sto_neg[j]
                             for j in range(i)
                         ),
                         sense=plp.LpConstraintLE,
-                        rhs=(
-                            self.plant_conf["battery_nominal_energy_capacity"]
-                            / self.timeStep
-                        )
-                        * (
-                            soc_init
-                            - self.plant_conf["battery_minimum_state_of_charge"]
-                        ),
+                        rhs=(self.plant_conf["battery_nominal_energy_capacity"] / self.time_step)
+                        * (soc_init - self.plant_conf["battery_minimum_state_of_charge"]),
                     )
-                    for i in set_I
+                    for i in set_i
                 }
             )
             constraints.update(
                 {
-                    "constraint_socfinal_{}".format(0): plp.LpConstraint(
+                    f"constraint_socfinal_{0}": plp.LpConstraint(
                         e=plp.lpSum(
-                            P_sto_pos[i]
-                            * (1 / self.plant_conf["battery_discharge_efficiency"])
-                            + self.plant_conf["battery_charge_efficiency"]
-                            * P_sto_neg[i]
-                            for i in set_I
+                            p_sto_pos[i] * (1 / self.plant_conf["battery_discharge_efficiency"])
+                            + self.plant_conf["battery_charge_efficiency"] * p_sto_neg[i]
+                            for i in set_i
                         ),
                         sense=plp.LpConstraintEQ,
                         rhs=(soc_init - soc_final)
                         * self.plant_conf["battery_nominal_energy_capacity"]
-                        / self.timeStep,
+                        / self.time_step,
                     )
                 }
             )
         opt_model.constraints = constraints
 
         ## Finally, we call the solver to solve our optimization model:
+        timeout = self.optim_conf["lp_solver_timeout"]
         # solving with default solver CBC
         if self.lp_solver == "PULP_CBC_CMD":
-            opt_model.solve(PULP_CBC_CMD(msg=0))
+            opt_model.solve(PULP_CBC_CMD(msg=0, timeLimit=timeout, threads=self.num_threads))
         elif self.lp_solver == "GLPK_CMD":
-            opt_model.solve(GLPK_CMD(msg=0))
+            opt_model.solve(GLPK_CMD(msg=0, timeLimit=timeout))
+        elif self.lp_solver == "HiGHS":
+            opt_model.solve(HiGHS(msg=0, timeLimit=timeout))
         elif self.lp_solver == "COIN_CMD":
-            opt_model.solve(COIN_CMD(msg=0, path=self.lp_solver_path))
+            opt_model.solve(
+                COIN_CMD(
+                    msg=0,
+                    path=self.lp_solver_path,
+                    timeLimit=timeout,
+                    threads=self.num_threads,
+                )
+            )
         else:
             self.logger.warning("Solver %s unknown, using default", self.lp_solver)
-            opt_model.solve()
+            opt_model.solve(PULP_CBC_CMD(msg=0, timeLimit=timeout, threads=self.num_threads))
 
         # The status of the solution is printed to the screen
         self.optim_status = plp.LpStatus[opt_model.status]
@@ -1093,125 +1632,122 @@ class Optimization:
 
         # Build results Dataframe
         opt_tp = pd.DataFrame()
-        opt_tp["P_PV"] = [P_PV[i] for i in set_I]
-        opt_tp["P_Load"] = [P_load[i] for i in set_I]
+        opt_tp["P_PV"] = [p_pv[i] for i in set_i]
+        opt_tp["P_Load"] = [p_load[i] for i in set_i]
         for k in range(self.optim_conf["number_of_deferrable_loads"]):
-            opt_tp["P_deferrable{}".format(k)] = [
-                P_deferrable[k][i].varValue for i in set_I
-            ]
-        opt_tp["P_grid_pos"] = [P_grid_pos[i].varValue for i in set_I]
-        opt_tp["P_grid_neg"] = [P_grid_neg[i].varValue for i in set_I]
-        opt_tp["P_grid"] = [
-            P_grid_pos[i].varValue + P_grid_neg[i].varValue for i in set_I
-        ]
+            opt_tp[f"P_deferrable{k}"] = [p_deferrable[k][i].varValue for i in set_i]
+        opt_tp["P_grid_pos"] = [p_grid_pos[i].varValue for i in set_i]
+        opt_tp["P_grid_neg"] = [p_grid_neg[i].varValue for i in set_i]
+        opt_tp["P_grid"] = [p_grid_pos[i].varValue + p_grid_neg[i].varValue for i in set_i]
         if self.optim_conf["set_use_battery"]:
-            opt_tp["P_batt"] = [
-                P_sto_pos[i].varValue + P_sto_neg[i].varValue for i in set_I
-            ]
-            SOC_opt_delta = [
+            opt_tp["P_batt"] = [p_sto_pos[i].varValue + p_sto_neg[i].varValue for i in set_i]
+            soc_opt_delta = [
                 (
-                    P_sto_pos[i].varValue
-                    * (1 / self.plant_conf["battery_discharge_efficiency"])
-                    + self.plant_conf["battery_charge_efficiency"]
-                    * P_sto_neg[i].varValue
+                    p_sto_pos[i].varValue * (1 / self.plant_conf["battery_discharge_efficiency"])
+                    + self.plant_conf["battery_charge_efficiency"] * p_sto_neg[i].varValue
                 )
-                * (self.timeStep / (self.plant_conf["battery_nominal_energy_capacity"]))
-                for i in set_I
+                * (self.time_step / (self.plant_conf["battery_nominal_energy_capacity"]))
+                for i in set_i
             ]
-            SOCinit = copy.copy(soc_init)
-            SOC_opt = []
-            for i in set_I:
-                SOC_opt.append(SOCinit - SOC_opt_delta[i])
-                SOCinit = SOC_opt[i]
-            opt_tp["SOC_opt"] = SOC_opt
+            soc_init = copy.copy(soc_init)
+            soc_opt = []
+            for i in set_i:
+                soc_opt.append(soc_init - soc_opt_delta[i])
+                soc_init = soc_opt[i]
+            opt_tp["SOC_opt"] = soc_opt
+
+            # Record Battery Stress Cost if active
+            if batt_stress_conf and batt_stress_conf["active"]:
+                opt_tp["batt_stress_cost"] = [batt_stress_conf["vars"][i].varValue for i in set_i]
+
         if self.plant_conf["inverter_is_hybrid"]:
-            opt_tp["P_hybrid_inverter"] = [P_hybrid_inverter[i].varValue for i in set_I]
+            opt_tp["P_hybrid_inverter"] = [p_hybrid_inverter[i].varValue for i in set_i]
+            # Record Inverter Stress Cost if active
+            if inv_stress_conf and inv_stress_conf["active"]:
+                opt_tp["inv_stress_cost"] = [inv_stress_conf["vars"][i].varValue for i in set_i]
+
         if self.plant_conf["compute_curtailment"]:
-            opt_tp["P_PV_curtailment"] = [P_PV_curtailment[i].varValue for i in set_I]
+            opt_tp["P_PV_curtailment"] = [p_pv_curtailment[i].varValue for i in set_i]
         opt_tp.index = data_opt.index
 
         # Lets compute the optimal cost function
-        P_def_sum_tp = []
-        for i in set_I:
-            P_def_sum_tp.append(
+        p_def_sum_tp = []
+        for i in set_i:
+            p_def_sum_tp.append(
                 sum(
-                    P_deferrable[k][i].varValue
+                    p_deferrable[k][i].varValue
                     for k in range(self.optim_conf["number_of_deferrable_loads"])
                 )
             )
-        opt_tp["unit_load_cost"] = [unit_load_cost[i] for i in set_I]
-        opt_tp["unit_prod_price"] = [unit_prod_price[i] for i in set_I]
+        opt_tp["unit_load_cost"] = [unit_load_cost[i] for i in set_i]
+        opt_tp["unit_prod_price"] = [unit_prod_price[i] for i in set_i]
         if self.optim_conf["set_total_pv_sell"]:
             opt_tp["cost_profit"] = [
                 -0.001
-                * self.timeStep
+                * self.time_step
                 * (
-                    unit_load_cost[i] * (P_load[i] + P_def_sum_tp[i])
-                    + unit_prod_price[i] * P_grid_neg[i].varValue
+                    unit_load_cost[i] * (p_load[i] + p_def_sum_tp[i])
+                    + unit_prod_price[i] * p_grid_neg[i].varValue
                 )
-                for i in set_I
+                for i in set_i
             ]
         else:
             opt_tp["cost_profit"] = [
                 -0.001
-                * self.timeStep
+                * self.time_step
                 * (
-                    unit_load_cost[i] * P_grid_pos[i].varValue
-                    + unit_prod_price[i] * P_grid_neg[i].varValue
+                    unit_load_cost[i] * p_grid_pos[i].varValue
+                    + unit_prod_price[i] * p_grid_neg[i].varValue
                 )
-                for i in set_I
+                for i in set_i
             ]
 
         if self.costfun == "profit":
             if self.optim_conf["set_total_pv_sell"]:
                 opt_tp["cost_fun_profit"] = [
                     -0.001
-                    * self.timeStep
+                    * self.time_step
                     * (
-                        unit_load_cost[i] * (P_load[i] + P_def_sum_tp[i])
-                        + unit_prod_price[i] * P_grid_neg[i].varValue
+                        unit_load_cost[i] * (p_load[i] + p_def_sum_tp[i])
+                        + unit_prod_price[i] * p_grid_neg[i].varValue
                     )
-                    for i in set_I
+                    for i in set_i
                 ]
             else:
                 opt_tp["cost_fun_profit"] = [
                     -0.001
-                    * self.timeStep
+                    * self.time_step
                     * (
-                        unit_load_cost[i] * P_grid_pos[i].varValue
-                        + unit_prod_price[i] * P_grid_neg[i].varValue
+                        unit_load_cost[i] * p_grid_pos[i].varValue
+                        + unit_prod_price[i] * p_grid_neg[i].varValue
                     )
-                    for i in set_I
+                    for i in set_i
                 ]
         elif self.costfun == "cost":
             if self.optim_conf["set_total_pv_sell"]:
                 opt_tp["cost_fun_cost"] = [
-                    -0.001
-                    * self.timeStep
-                    * unit_load_cost[i]
-                    * (P_load[i] + P_def_sum_tp[i])
-                    for i in set_I
+                    -0.001 * self.time_step * unit_load_cost[i] * (p_load[i] + p_def_sum_tp[i])
+                    for i in set_i
                 ]
             else:
                 opt_tp["cost_fun_cost"] = [
-                    -0.001 * self.timeStep * unit_load_cost[i] * P_grid_pos[i].varValue
-                    for i in set_I
+                    -0.001 * self.time_step * unit_load_cost[i] * p_grid_pos[i].varValue
+                    for i in set_i
                 ]
         elif self.costfun == "self-consumption":
             if type_self_conso == "maxmin":
                 opt_tp["cost_fun_selfcons"] = [
-                    -0.001 * self.timeStep * unit_load_cost[i] * SC[i].varValue
-                    for i in set_I
+                    -0.001 * self.time_step * unit_load_cost[i] * SC[i].varValue for i in set_i
                 ]
             elif type_self_conso == "bigm":
                 opt_tp["cost_fun_selfcons"] = [
                     -0.001
-                    * self.timeStep
+                    * self.time_step
                     * (
-                        unit_load_cost[i] * P_grid_pos[i].varValue
-                        + unit_prod_price[i] * P_grid_neg[i].varValue
+                        unit_load_cost[i] * p_grid_pos[i].varValue
+                        + unit_prod_price[i] * p_grid_neg[i].varValue
                     )
-                    for i in set_I
+                    for i in set_i
                 ]
         else:
             self.logger.error("The cost function specified type is not valid")
@@ -1222,25 +1758,58 @@ class Optimization:
         # Debug variables
         if debug:
             for k in range(self.optim_conf["number_of_deferrable_loads"]):
-                opt_tp[f"P_def_start_{k}"] = [P_def_start[k][i].varValue for i in set_I]
-                opt_tp[f"P_def_bin2_{k}"] = [P_def_bin2[k][i].varValue for i in set_I]
+                opt_tp[f"P_def_start_{k}"] = [p_def_start[k][i].varValue for i in set_i]
+                opt_tp[f"P_def_bin2_{k}"] = [p_def_bin2[k][i].varValue for i in set_i]
+
         for i, predicted_temp in predicted_temps.items():
             opt_tp[f"predicted_temp_heater{i}"] = pd.Series(
                 [
-                    round(pt.value(), 2)
-                    if isinstance(pt, plp.LpAffineExpression)
-                    else pt
+                    round(pt.value(), 2) if isinstance(pt, plp.LpAffineExpression) else pt
                     for pt in predicted_temp
                 ],
                 index=opt_tp.index,
             )
-            opt_tp[f"target_temp_heater{i}"] = pd.Series(
-                self.optim_conf["def_load_config"][i]["thermal_config"][
-                    "desired_temperatures"
-                ],
+            # Try desired, then min, then max, else empty list
+            if "thermal_config" in self.optim_conf["def_load_config"][i]:
+                thermal_config = self.optim_conf["def_load_config"][i]["thermal_config"]
+                target_temps = thermal_config.get("desired_temperatures")
+                # If desired_temperatures is missing, try to fallback to min or max for visualization
+                if not target_temps:
+                    target_temps = thermal_config.get("min_temperatures")
+                if not target_temps:
+                    target_temps = thermal_config.get("max_temperatures")
+                # If we found something, add it to the DF
+                if target_temps:
+                    opt_tp[f"target_temp_heater{i}"] = pd.Series(
+                        target_temps,
+                        index=opt_tp.index,
+                    )
+
+        # Add heating demands for thermal loads (both thermal_config and thermal_battery)
+        for i, heating_demand in heating_demands.items():
+            opt_tp[f"heating_demand_heater{i}"] = pd.Series(
+                heating_demand,
                 index=opt_tp.index,
             )
 
+        # Battery initialization logging
+        if self.optim_conf["set_use_battery"]:
+            self.logger.debug(
+                f"Battery usage enabled. Initial SOC: {soc_init}, Final SOC: {soc_final}"
+            )
+
+        # Deferrable load initialization logging
+        self.logger.debug(f"Deferrable load operating hours: {def_total_hours}")
+        self.logger.debug(f"Deferrable load timesteps: {def_total_timestep}")
+        self.logger.debug(f"Deferrable load start timesteps: {def_start_timestep}")
+        self.logger.debug(f"Deferrable load end timesteps: {def_end_timestep}")
+
+        # Objective function logging
+        self.logger.debug(f"Selected cost function type: {self.costfun}")
+
+        # Solver execution logging
+        self.logger.debug(f"Solver selected: {self.lp_solver}")
+        self.logger.info(f"Optimization status: {self.optim_status}")
         return opt_tp
 
     def perform_perfect_forecast_optim(
@@ -1248,7 +1817,7 @@ class Optimization:
     ) -> pd.DataFrame:
         r"""
         Perform an optimization on historical data (perfectly known PV production).
-        
+
         :param df_input_data: A DataFrame containing all the input data used for \
             the optimization, notably photovoltaics and load consumption powers.
         :type df_input_data: pandas.DataFrame
@@ -1267,26 +1836,40 @@ class Optimization:
         self.opt_res = pd.DataFrame()
         for day in self.days_list_tz:
             self.logger.info(
-                "Solving for day: "
-                + str(day.day)
-                + "-"
-                + str(day.month)
-                + "-"
-                + str(day.year)
+                "Solving for day: " + str(day.day) + "-" + str(day.month) + "-" + str(day.year)
             )
             # Prepare data
-            day_start = day.isoformat()
-            day_end = (day + self.time_delta - self.freq).isoformat()
-            data_tp = df_input_data.copy().loc[
-                pd.date_range(start=day_start, end=day_end, freq=self.freq)
-            ]
-            P_PV = data_tp[self.var_PV].values
-            P_load = data_tp[self.var_load_new].values
+            if day.tzinfo is None:
+                day = day.replace(tzinfo=self.time_zone)  # Assign timezone if naive
+            else:
+                day = day.astimezone(self.time_zone)
+            day_start = day
+            day_end = day + self.time_delta - self.freq
+            if day_start.tzinfo != day_end.tzinfo:
+                self.logger.warning(
+                    f"Skipping day {day} as days have ddifferent timezone, probably because of DST."
+                )
+                continue  # Skip this day and move to the next iteration
+            else:
+                day_start = day_start.astimezone(self.time_zone).isoformat()
+                day_end = day_end.astimezone(self.time_zone).isoformat()
+                # Generate the date range for the current day
+                day_range = pd.date_range(start=day_start, end=day_end, freq=self.freq)
+            # Check if all timestamps in the range exist in the DataFrame index
+            if not day_range.isin(df_input_data.index).all():
+                self.logger.warning(
+                    f"Skipping day {day} as some timestamps are missing in the data."
+                )
+                continue  # Skip this day and move to the next iteration
+            # If all timestamps exist, proceed with the data preparation
+            data_tp = df_input_data.copy().loc[day_range]
+            p_pv = data_tp[self.var_pv].values
+            p_load = data_tp[self.var_load_new].values
             unit_load_cost = data_tp[self.var_load_cost].values  # €/kWh
             unit_prod_price = data_tp[self.var_prod_price].values  # €/kWh
             # Call optimization function
             opt_tp = self.perform_optimization(
-                data_tp, P_PV, P_load, unit_load_cost, unit_prod_price
+                data_tp, p_pv, p_load, unit_load_cost, unit_prod_price
             )
             if len(self.opt_res) == 0:
                 self.opt_res = opt_tp
@@ -1296,20 +1879,20 @@ class Optimization:
         return self.opt_res
 
     def perform_dayahead_forecast_optim(
-        self, df_input_data: pd.DataFrame, P_PV: pd.Series, P_load: pd.Series
+        self, df_input_data: pd.DataFrame, p_pv: pd.Series, p_load: pd.Series
     ) -> pd.DataFrame:
         r"""
         Perform a day-ahead optimization task using real forecast data. \
         This type of optimization is intented to be launched once a day.
-        
+
         :param df_input_data: A DataFrame containing all the input data used for \
             the optimization, notably the unit load cost for power consumption.
         :type df_input_data: pandas.DataFrame
-        :param P_PV: The forecasted PV power production.
-        :type P_PV: pandas.DataFrame
-        :param P_load: The forecasted Load power consumption. This power should \
+        :param p_pv: The forecasted PV power production.
+        :type p_pv: pandas.DataFrame
+        :param p_load: The forecasted Load power consumption. This power should \
             not include the power from the deferrable load that we want to find.
-        :type P_load: pandas.DataFrame
+        :type p_load: pandas.DataFrame
         :return: opt_res: A DataFrame containing the optimization results
         :rtype: pandas.DataFrame
 
@@ -1320,8 +1903,8 @@ class Optimization:
         # Call optimization function
         self.opt_res = self.perform_optimization(
             df_input_data,
-            P_PV.values.ravel(),
-            P_load.values.ravel(),
+            p_pv.values.ravel(),
+            p_load.values.ravel(),
             unit_load_cost,
             unit_prod_price,
         )
@@ -1330,29 +1913,30 @@ class Optimization:
     def perform_naive_mpc_optim(
         self,
         df_input_data: pd.DataFrame,
-        P_PV: pd.Series,
-        P_load: pd.Series,
+        p_pv: pd.Series,
+        p_load: pd.Series,
         prediction_horizon: int,
-        soc_init: Optional[float] = None,
-        soc_final: Optional[float] = None,
-        def_total_hours: Optional[list] = None,
-        def_start_timestep: Optional[list] = None,
-        def_end_timestep: Optional[list] = None,
+        soc_init: float | None = None,
+        soc_final: float | None = None,
+        def_total_hours: list | None = None,
+        def_total_timestep: list | None = None,
+        def_start_timestep: list | None = None,
+        def_end_timestep: list | None = None,
     ) -> pd.DataFrame:
         r"""
         Perform a naive approach to a Model Predictive Control (MPC). \
         This implementaion is naive because we are not using the formal formulation \
         of a MPC. Only the sense of a receiding horizon is considered here. \
         This optimization is more suitable for higher optimization frequency, ex: 5min.
-        
+
         :param df_input_data: A DataFrame containing all the input data used for \
             the optimization, notably the unit load cost for power consumption.
         :type df_input_data: pandas.DataFrame
-        :param P_PV: The forecasted PV power production.
-        :type P_PV: pandas.DataFrame
-        :param P_load: The forecasted Load power consumption. This power should \
+        :param p_pv: The forecasted PV power production.
+        :type p_pv: pandas.DataFrame
+        :param p_load: The forecasted Load power consumption. This power should \
             not include the power from the deferrable load that we want to find.
-        :type P_load: pandas.DataFrame
+        :type p_load: pandas.DataFrame
         :param prediction_horizon: The prediction horizon of the MPC controller in number \
             of optimization time steps.
         :type prediction_horizon: int
@@ -1361,7 +1945,10 @@ class Optimization:
         :type soc_init: float
         :param soc_final: The final battery SOC for the optimization. This parameter \
             is optional, if not given soc_init = soc_final = soc_target from the configuration file.
-        :type soc_final: 
+        :type soc_final:
+        :param def_total_timestep: The functioning timesteps for this iteration for each deferrable load. \
+            (For continuous deferrable loads: functioning timesteps at nominal power)
+        :type def_total_timestep: list
         :param def_total_hours: The functioning hours for this iteration for each deferrable load. \
             (For continuous deferrable loads: functioning hours at nominal power)
         :type def_total_hours: list
@@ -1388,13 +1975,14 @@ class Optimization:
         # Call optimization function
         self.opt_res = self.perform_optimization(
             df_input_data,
-            P_PV.values.ravel(),
-            P_load.values.ravel(),
+            p_pv.values.ravel(),
+            p_load.values.ravel(),
             unit_load_cost,
             unit_prod_price,
             soc_init=soc_init,
             soc_final=soc_final,
             def_total_hours=def_total_hours,
+            def_total_timestep=def_total_timestep,
             def_start_timestep=def_start_timestep,
             def_end_timestep=def_end_timestep,
         )
@@ -1403,7 +1991,7 @@ class Optimization:
     @staticmethod
     def validate_def_timewindow(
         start: int, end: int, min_steps: int, window: int
-    ) -> Tuple[int, int, str]:
+    ) -> tuple[int, int, str]:
         r"""
         Helper function to validate (and if necessary: correct) the defined optimization window of a deferrable load.