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

emhass/optimization.py

@@ -1,25 +1,24 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-import logging
-import copy
-import pathlib
 import bz2
+import copy
+import logging
+import os
 import pickle as cPickle
-from typing import Optional, Tuple
-import pandas as pd
+from math import ceil
+
 import numpy as np
+import pandas as pd
 import pulp as plp
-from pulp import PULP_CBC_CMD, COIN_CMD, GLPK_CMD
-from math import ceil
+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
@@ -27,18 +26,26 @@ class Optimization:
     - perform_perfect_forecast_optim
 
     - perform_dayahead_forecast_optim
-    
+
     - perform_naive_mpc_optim
-    
+
     """
 
-    def __init__(self, retrieve_hass_conf: dict, optim_conf: dict, plant_conf: dict, 
-                 var_load_cost: str, var_prod_price: str, 
-                 costfun: str, emhass_conf: dict, logger: logging.Logger, 
-                 opt_time_delta: Optional[int] = 24) -> None:
+    def __init__(
+        self,
+        retrieve_hass_conf: dict,
+        optim_conf: dict,
+        plant_conf: dict,
+        var_load_cost: str,
+        var_prod_price: str,
+        costfun: str,
+        emhass_conf: dict,
+        logger: logging.Logger,
+        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
@@ -61,56 +68,154 @@ 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['freq']
-        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['var_PV']
-        self.var_load = self.retrieve_hass_conf['var_load']
-        self.var_load_new = self.var_load+'_positive'
+        self.freq = self.retrieve_hass_conf["optimization_time_step"]
+        self.time_zone = self.retrieve_hass_conf["time_zone"]
+        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 'lp_solver' in optim_conf.keys():
-            self.lp_solver = optim_conf['lp_solver']
+        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:
-            self.lp_solver = 'default'
-        if 'lp_solver_path' in optim_conf.keys():
-            self.lp_solver_path = optim_conf['lp_solver_path']
+            self.lp_solver = "default"
+        if "lp_solver_path" in optim_conf.keys():
+            self.lp_solver_path = optim_conf["lp_solver_path"]
         else:
-            self.lp_solver_path = 'empty'
-        if self.lp_solver != 'COIN_CMD' and self.lp_solver_path != 'empty':
-            self.logger.error("Use COIN_CMD solver name if you want to set a path for the LP solver")
-        if self.lp_solver == 'COIN_CMD' and self.lp_solver_path == 'empty': #if COIN_CMD but lp_solver_path is empty
-            self.logger.warning("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'  
-
-    def perform_optimization(self, data_opt: pd.DataFrame, 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) -> pd.DataFrame:
+            self.lp_solver_path = "empty"
+        if self.lp_solver != "COIN_CMD" and self.lp_solver_path != "empty":
+            self.logger.error(
+                "Use COIN_CMD solver name if you want to set a path for the LP solver"
+            )
+        if (
+            self.lp_solver == "COIN_CMD" and self.lp_solver_path == "empty"
+        ):  # if COIN_CMD but lp_solver_path is empty
+            self.logger.warning(
+                "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,
+        unit_load_cost: np.array,
+        unit_prod_price: np.array,
+        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
@@ -124,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.
@@ -138,521 +246,1377 @@ class Optimization:
 
         """
         # Prepare some data in the case of a battery
-        if self.optim_conf['set_use_battery']:
+        if self.optim_conf["set_use_battery"]:
             if soc_init is None:
                 if soc_final is not None:
                     soc_init = soc_final
                 else:
-                    soc_init = self.plant_conf['SOCtarget']
+                    soc_init = self.plant_conf["battery_target_state_of_charge"]
             if soc_final is None:
                 if soc_init is not None:
                     soc_final = soc_init
                 else:
-                    soc_final = self.plant_conf['SOCtarget']
-        if def_total_hours is None:
-            def_total_hours = self.optim_conf['def_total_hours']
+                    soc_final = self.plant_conf["battery_target_state_of_charge"]
+            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['def_start_timestep']
+            def_start_timestep = self.optim_conf["start_timesteps_of_each_deferrable_load"]
         if def_end_timestep is None:
-            def_end_timestep = self.optim_conf['def_end_timestep']
-        type_self_conso = 'bigm' # maxmin
+            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  = {(i):plp.LpVariable(cat='Continuous',
-                                          lowBound=-self.plant_conf['P_to_grid_max'], upBound=0,
-                                          name="P_grid_neg{}".format(i)) for i in set_I}
-        P_grid_pos  = {(i):plp.LpVariable(cat='Continuous',
-                                          lowBound=0, upBound=self.plant_conf['P_from_grid_max'],
-                                          name="P_grid_pos{}".format(i)) for i in set_I}
-        P_deferrable = []
-        P_def_bin1 = []
-        for k in range(self.optim_conf['num_def_loads']):
-            if type(self.optim_conf['P_deferrable_nom'][k]) == list:
-                upBound = np.max(self.optim_conf['P_deferrable_nom'][k])
+        p_grid_neg = {
+            (i): plp.LpVariable(
+                cat="Continuous",
+                lowBound=-self.plant_conf["maximum_power_to_grid"],
+                upBound=0,
+                name=f"P_grid_neg{i}",
+            )
+            for i in set_i
+        }
+        p_grid_pos = {
+            (i): plp.LpVariable(
+                cat="Continuous",
+                lowBound=0,
+                upBound=self.plant_conf["maximum_power_from_grid"],
+                name=f"P_grid_pos{i}",
+            )
+            for i in set_i
+        }
+        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['P_deferrable_nom'][k]
-            if self.optim_conf['treat_def_as_semi_cont'][k]:
-                P_deferrable.append({(i):plp.LpVariable(cat='Continuous',
-                                                        name="P_deferrable{}_{}".format(k, i)) for i in set_I})
+                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(
+                    {
+                        (i): plp.LpVariable(cat="Continuous", name=f"P_deferrable{k}_{i}")
+                        for i in set_i
+                    }
+                )
             else:
-                P_deferrable.append({(i):plp.LpVariable(cat='Continuous',
-                                                        lowBound=0, upBound=upBound,
-                                                        name="P_deferrable{}_{}".format(k, 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_start = []
-        P_def_bin2 = []
-        for k in range(self.optim_conf['num_def_loads']):
-            P_def_start.append({(i):plp.LpVariable(cat='Binary',
-                                                   name="P_def{}_start_{}".format(k, 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})
-        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}
-        if self.optim_conf['set_use_battery']:
-            P_sto_pos  = {(i):plp.LpVariable(cat='Continuous', 
-                                             lowBound=0, upBound=self.plant_conf['Pd_max'],
-                                             name="P_sto_pos_{0}".format(i)) for i in set_I}
-            P_sto_neg  = {(i):plp.LpVariable(cat='Continuous', 
-                                             lowBound=-self.plant_conf['Pc_max'], upBound=0,
-                                             name="P_sto_neg_{0}".format(i)) for i in set_I}
+                p_deferrable.append(
+                    {
+                        (i): plp.LpVariable(
+                            cat="Continuous",
+                            lowBound=0,
+                            upBound=up_bound,
+                            name=f"P_deferrable{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 = []
+        for k in range(self.optim_conf["number_of_deferrable_loads"]):
+            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=f"P_def{k}_bin2_{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"]:
+            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=f"P_sto_pos_{i}",
+                )
+                for i in set_i
+            }
+            p_sto_neg = {
+                (i): plp.LpVariable(
+                    cat="Continuous",
+                    lowBound=-np.abs(self.plant_conf["battery_charge_power_max"]),
+                    upBound=0,
+                    name=f"P_sto_neg_{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}
-
-        if self.costfun == 'self-consumption':
-            SC  = {(i):plp.LpVariable(cat='Continuous',
-                                      name="SC_{}".format(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_PV_curtailment = {(i):plp.LpVariable(cat='Continuous', lowBound=0,
-                                               name="P_PV_curtailment{}".format(i)) 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=f"SC_{i}") for i in set_i}
+
+        if self.plant_conf["inverter_is_hybrid"]:
+            p_hybrid_inverter = {
+                (i): plp.LpVariable(cat="Continuous", name=f"P_hybrid_inverter{i}") for i in set_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),
+            )
+            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(plp.lpSum(P_deferrable[k][i] for k in range(self.optim_conf['num_def_loads'])))
-        if self.costfun == 'profit':
-            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]) + \
-                    unit_prod_price[i]*P_grid_neg[i]) for i in set_I)
+        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"])
+                )
+            )
+        if self.costfun == "profit":
+            if self.optim_conf["set_total_pv_sell"]:
+                objective = plp.lpSum(
+                    -0.001
+                    * self.time_step
+                    * (
+                        unit_load_cost[i] * (p_load[i] + p_def_sum[i])
+                        + unit_prod_price[i] * p_grid_neg[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)
-        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)
+                objective = plp.lpSum(
+                    -0.001
+                    * 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.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)
-        elif self.costfun == 'self-consumption':
-            if type_self_conso == 'bigm':
+                objective = plp.lpSum(
+                    -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*(bigm*unit_load_cost[i]*P_grid_pos[i] + \
-                    unit_prod_price[i]*P_grid_neg[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)
+                objective = plp.lpSum(
+                    -0.001
+                    * self.time_step
+                    * (
+                        bigm * unit_load_cost[i] * p_grid_pos[i]
+                        + unit_prod_price[i] * p_grid_neg[i]
+                    )
+                    for i in set_i
+                )
+            elif type_self_conso == "maxmin":
+                objective = plp.lpSum(
+                    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")
         else:
             self.logger.error("The cost function specified type is not valid")
         # Add more terms to the objective function in the case of battery use
-        if self.optim_conf['set_use_battery']:
-            objective = objective + plp.lpSum(-0.001*self.timeStep*(
-                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)
+        if self.optim_conf["set_use_battery"]:
+            objective = objective + plp.lpSum(
+                -0.001
+                * self.time_step
+                * (
+                    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
+            )
 
         # Add term penalizing each startup where configured
-        if ("def_start_penalty" in self.optim_conf and self.optim_conf["def_start_penalty"]):
-            for k in range(self.optim_conf["num_def_loads"]):
-                if (len(self.optim_conf["def_start_penalty"]) > k and self.optim_conf["def_start_penalty"][k]):
+        if (
+            "set_deferrable_startup_penalty" in self.optim_conf
+            and self.optim_conf["set_deferrable_startup_penalty"]
+        ):
+            for k in range(self.optim_conf["number_of_deferrable_loads"]):
+                if (
+                    len(self.optim_conf["set_deferrable_startup_penalty"]) > k
+                    and self.optim_conf["set_deferrable_startup_penalty"][k]
+                ):
                     objective = objective + plp.lpSum(
-                        -0.001 * self.timeStep * self.optim_conf["def_start_penalty"][k] * P_def_start[k][i] *\
-                            unit_load_cost[i] * self.optim_conf['P_deferrable_nom'][k]
-                        for i in set_I)
+                        -0.001
+                        * self.time_step
+                        * self.optim_conf["set_deferrable_startup_penalty"][k]
+                        * p_def_start[k][i]
+                        * unit_load_cost[i]
+                        * self.optim_conf["nominal_power_of_deferrable_loads"][k]
+                        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] ,
-                    sense = plp.LpConstraintEQ,
-                    rhs = 0)
-                for i in set_I}
+        if self.plant_conf["inverter_is_hybrid"]:
+            constraints = {
+                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
+            }
         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],
-                        sense = plp.LpConstraintEQ,
-                        rhs = 0)
-                    for i in set_I}
+            if self.plant_conf["compute_curtailment"]:
+                constraints = {
+                    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
+                }
             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],
-                        sense = plp.LpConstraintEQ,
-                        rhs = 0)
-                    for i in set_I}
-        
-        # Constraint for hybrid inverter and curtailment cases
-        if type(self.plant_conf['module_model']) == list:
-            P_nom_inverter = 0.0
-            for i in range(len(self.plant_conf['inverter_model'])):
-                if type(self.plant_conf['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['inverter_model'][i]]
-                    P_nom_inverter += inverter.Paco
+                constraints = {
+                    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
+                }
+
+        # 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"]:
+            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]
+                    )
                 else:
-                    P_nom_inverter += self.plant_conf['inverter_model'][i]
-        else:
-            if type(self.plant_conf['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['inverter_model']]
-                P_nom_inverter = inverter.Paco
-            else:
-                P_nom_inverter = self.plant_conf['inverter_model']
-        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)
-                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)
-                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,
-                        rhs = 0)
-                    for i in set_I})
+                    e_dc_balance = (p_pv[i] + p_sto_pos[i] + p_sto_neg[i]) - (
+                        p_dc_ac[i] - p_ac_dc[i]
+                    )
+
+                constraints.update(
+                    {
+                        f"constraint_dc_bus_balance_{i}": plp.LpConstraint(
+                            e=e_dc_balance,
+                            sense=plp.LpConstraintEQ,
+                            rhs=0,
+                        )
+                    }
+                )
+
+                # The AC power is defined by the efficiency-adjusted DC flows
+                constraints.update(
+                    {
+                        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,
+                        )
+                    }
+                )
+
+                # Use the binary variable to ensure only one direction is active at a time
+                constraints.update(
+                    {
+                        # 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,
+                        ),
+                        # 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':
-            if type_self_conso == 'maxmin': # maxmin linear problem
-                constraints.update({"constraint_selfcons_PV1_{}".format(i) : 
-                    plp.LpConstraint(
-                        e = SC[i] - P_PV[i],
-                        sense = plp.LpConstraintLE,
-                        rhs = 0)
-                    for i in set_I})
-                constraints.update({"constraint_selfcons_PV2_{}".format(i) : 
-                    plp.LpConstraint(
-                        e = SC[i] - P_load[i] - P_def_sum[i],
-                        sense = plp.LpConstraintLE,
-                        rhs = 0)
-                    for i in set_I})
+        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['P_from_grid_max']*D[i],
-                sense = plp.LpConstraintLE,
-                rhs = 0)
-            for i in set_I})
-        constraints.update({"constraint_pgridneg_{}".format(i) : 
-            plp.LpConstraint(
-                e = -P_grid_neg[i] - self.plant_conf['P_to_grid_max']*(1-D[i]),
-                sense = plp.LpConstraintLE,
-                rhs = 0)
-            for i in set_I})
+        constraints.update(
+            {
+                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
+            }
+        )
+        constraints.update(
+            {
+                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
+            }
+        )
 
         # Treat deferrable loads constraints
         predicted_temps = {}
-        for k in range(self.optim_conf['num_def_loads']):
-            
-            if type(self.optim_conf['P_deferrable_nom'][k]) == list:
+        heating_demands = {}  # Store heating demand for thermal loads
+        for k in range(self.optim_conf["number_of_deferrable_loads"]):
+            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
-                power_sequence = self.optim_conf['P_deferrable_nom'][k]
+                power_sequence = self.optim_conf["nominal_power_of_deferrable_loads"][k]
                 sequence_length = len(power_sequence)
+
                 def create_matrix(input_list, n):
                     matrix = []
                     for i in range(n + 1):
                         row = [0] * i + input_list + [0] * (n - i)
-                        matrix.append(row[:n*2])
+                        matrix.append(row[: n * 2])
                     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')
-                constraints.update({f"single_value_constraint_{k}" :
-                    plp.LpConstraint(
-                        e = plp.lpSum(y[i] for i in range(len(matrix))) - 1,
-                        sense = plp.LpConstraintEQ,
-                        rhs = 0)
-                    })
-                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),
-                        sense = plp.LpConstraintEQ,
-                        rhs = 0)
-                    })
-                constraints.update({f"pdef{k}_positive_constraint_{i}" :
-                    plp.LpConstraint(
-                        e = P_deferrable[k][i],
-                        sense = plp.LpConstraintGE,
-                        rhs = 0)
-                    for i in set_I})
+
+                matrix = create_matrix(power_sequence, n - sequence_length)
+                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(
+                    {
+                        f"single_value_constraint_{k}": plp.LpConstraint(
+                            e=plp.lpSum(y[i] for i in range(len(matrix))) - 1,
+                            sense=plp.LpConstraintEQ,
+                            rhs=0,
+                        )
+                    }
+                )
+                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),
+                            sense=plp.LpConstraintEQ,
+                            rhs=0,
+                        )
+                    }
+                )
+                constraints.update(
+                    {
+                        f"pdef{k}_positive_constraint_{i}": plp.LpConstraint(
+                            e=p_deferrable[k][i], sense=plp.LpConstraintGE, rhs=0
+                        )
+                        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],
-                            sense = plp.LpConstraintEQ,
-                            rhs = 0)
-                        for i in set_I})
-            
-            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"]
+                    constraints.update(
+                        {
+                            f"pdef{k}_value_constraint_{num}_{i}": plp.LpConstraint(
+                                e=p_deferrable[k][i] - mat[i] * y[num],
+                                sense=plp.LpConstraintEQ,
+                                rhs=0,
+                            )
+                            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"]
+
+                    # 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['P_deferrable_nom'][k]))
-                                - (cooling_constant * (predicted_temp[I-1] - outdoor_temperature_forecast[I-1])))
-                            if len(desired_temperatures) > I and desired_temperatures[I]:
-                                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],
+
+                    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
+                                * self.time_step
+                                * (
+                                    predicted_temp[index - 1]
+                                    - outdoor_temperature_forecast.iloc[index - 1]
+                                )
+                            )
+                        )
+
+                        # 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],
                                     )
-                                })
-                        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,
+                                }
                             )
-                        for I in set_I})
-                        predicted_temps[k] = predicted_temp
-            
-            else:
-                
-                if def_total_hours[k] > 0:
-                    # Total time of deferrable load
-                    constraints.update({"constraint_defload{}_energy".format(k) :
-                        plp.LpConstraint(
-                            e = plp.lpSum(P_deferrable[k][i]*self.timeStep for i in set_I),
-                            sense = plp.LpConstraintEQ,
-                            rhs = def_total_hours[k]*self.optim_conf['P_deferrable_nom'][k])
-                        })
-                
+
+                        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(
+                                    {
+                                        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(
+                            {
+                                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
+                            }
+                        )
+
+                    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(
+                        {
+                            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.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)
-            if warning is not None: 
-                self.logger.warning("Deferrable load {} : {}".format(k, warning))
-            self.logger.debug("Deferrable load {}: Validated optimization window: {} --> {}".format(
-                k, def_start, def_end))
-            if def_start > 0:                    
-                constraints.update({"constraint_defload{}_start_timestep".format(k) :
-                    plp.LpConstraint(
-                        e = plp.lpSum(P_deferrable[k][i]*self.timeStep for i in range(0, def_start)),
-                        sense = plp.LpConstraintEQ,
-                        rhs = 0)
-                    })
-            if def_end > 0:                    
-                constraints.update({"constraint_defload{}_end_timestep".format(k) :
-                    plp.LpConstraint(
-                        e = plp.lpSum(P_deferrable[k][i]*self.timeStep for i in range(def_end, n)),
-                        sense = plp.LpConstraintEQ,
-                        rhs = 0)
-                    })
-                
+            self.logger.debug(
+                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(f"Deferrable load {k} : {warning}")
+            self.logger.debug(
+                f"Deferrable load {k}: Validated optimization window: {def_start} --> {def_end}"
+            )
+            if def_start > 0:
+                constraints.update(
+                    {
+                        f"constraint_defload{k}_start_timestep": plp.LpConstraint(
+                            e=plp.lpSum(
+                                p_deferrable[k][i] * self.time_step for i in range(0, def_start)
+                            ),
+                            sense=plp.LpConstraintEQ,
+                            rhs=0,
+                        )
+                    }
+                )
+            if def_end > 0:
+                constraints.update(
+                    {
+                        f"constraint_defload{k}_end_timestep": plp.LpConstraint(
+                            e=plp.lpSum(
+                                p_deferrable[k][i] * self.time_step for i in range(def_end, n)
+                            ),
+                            sense=plp.LpConstraintEQ,
+                            rhs=0,
+                        )
+                    }
+                )
+
+            # 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 ("def_current_state" in self.optim_conf and len(self.optim_conf["def_current_state"]) > k):
+            if (
+                "def_current_state" in self.optim_conf
+                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
-            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})
-            # 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],
-                    sense=plp.LpConstraintLE,
-                    rhs=0)
-                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_deferrable < p_def_bin2 * 1 million
+            # p_deferrable must be zero if p_def_bin2 is zero
+            constraints.update(
+                {
+                    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
+                }
+            )
+            # p_deferrable - p_def_bin2 <= 0
+            # p_def_bin2 must be zero if p_deferrable is zero
+            constraints.update(
+                {
+                    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
+                }
+            )
+            # 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),
-                    sense=plp.LpConstraintGE,
-                    rhs=0)
-                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
-            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],
-                    sense=plp.LpConstraintLE,
-                    rhs=1)
-                for i in set_I})
-            
-            # Treat deferrable as a fixed value variable with just one startup
-            if self.optim_conf['set_def_constant'][k]:
-                # 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),
-                    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)
-                })
-        
-            # Treat deferrable load as a semi-continuous variable
-            if self.optim_conf['treat_def_as_semi_cont'][k]:
-                constraints.update({"constraint_pdef{}_semicont1_{}".format(k, i) : 
-                    plp.LpConstraint(
-                        e=P_deferrable[k][i] - self.optim_conf['P_deferrable_nom'][k]*P_def_bin1[k][i],
+            constraints.update(
+                {
+                    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})
-                constraints.update({"constraint_pdef{}_semicont2_{}".format(k, i) :
-                    plp.LpConstraint(
-                        e=P_deferrable[k][i] - self.optim_conf['P_deferrable_nom'][k]*P_def_bin1[k][i],
+                        rhs=0,
+                    )
+                    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
+            constraints.update(
+                {
+                    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=0)
-                    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_def_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)
-            #     })
+                        rhs=1,
+                    )
+                    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
+                constraints.update(
+                    {
+                        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.
+                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(
+                    {
+                        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],
+                            sense=plp.LpConstraintGE,
+                            rhs=0,
+                        )
+                        for i in set_i
+                    }
+                )
+                constraints.update(
+                    {
+                        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],
+                            sense=plp.LpConstraintLE,
+                            rhs=0,
+                        )
+                        for i in set_i
+                    }
+                )
 
         # The battery constraints
-        if self.optim_conf['set_use_battery']:
+        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)
-                    for i in set_I})
+            if self.optim_conf["set_nocharge_from_grid"]:
+                constraints.update(
+                    {
+                        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
+                    }
+                )
             # 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)
-                    for i in set_I})
+            if self.optim_conf["set_nodischarge_to_grid"]:
+                constraints.update(
+                    {
+                        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
+                    }
+                )
             # 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], 
-                                     sense = plp.LpConstraintLE, 
-                                     rhs = self.timeStep*self.optim_conf['battery_dynamic_max']*self.plant_conf['Pd_max']) 
-                    for i in range(n-1)})
-                constraints.update({"constraint_pos_batt_dynamic_min_{}".format(i) : 
-                    plp.LpConstraint(e = P_sto_pos[i+1] - P_sto_pos[i], 
-                                     sense = plp.LpConstraintGE, 
-                                     rhs = self.timeStep*self.optim_conf['battery_dynamic_min']*self.plant_conf['Pd_max']) 
-                    for i in range(n-1)})
-                constraints.update({"constraint_neg_batt_dynamic_max_{}".format(i) : 
-                    plp.LpConstraint(e = P_sto_neg[i+1] - P_sto_neg[i], 
-                                     sense = plp.LpConstraintLE, 
-                                     rhs = self.timeStep*self.optim_conf['battery_dynamic_max']*self.plant_conf['Pc_max']) 
-                    for i in range(n-1)})
-                constraints.update({"constraint_neg_batt_dynamic_min_{}".format(i) : 
-                    plp.LpConstraint(e = P_sto_neg[i+1] - P_sto_neg[i], 
-                                     sense = plp.LpConstraintGE, 
-                                     rhs = self.timeStep*self.optim_conf['battery_dynamic_min']*self.plant_conf['Pc_max']) 
-                    for i in range(n-1)})
+            if self.optim_conf["set_battery_dynamic"]:
+                constraints.update(
+                    {
+                        f"constraint_pos_batt_dynamic_max_{i}": plp.LpConstraint(
+                            e=p_sto_pos[i + 1] - p_sto_pos[i],
+                            sense=plp.LpConstraintLE,
+                            rhs=self.time_step
+                            * self.optim_conf["battery_dynamic_max"]
+                            * self.plant_conf["battery_discharge_power_max"],
+                        )
+                        for i in range(n - 1)
+                    }
+                )
+                constraints.update(
+                    {
+                        f"constraint_pos_batt_dynamic_min_{i}": plp.LpConstraint(
+                            e=p_sto_pos[i + 1] - p_sto_pos[i],
+                            sense=plp.LpConstraintGE,
+                            rhs=self.time_step
+                            * self.optim_conf["battery_dynamic_min"]
+                            * self.plant_conf["battery_discharge_power_max"],
+                        )
+                        for i in range(n - 1)
+                    }
+                )
+                constraints.update(
+                    {
+                        f"constraint_neg_batt_dynamic_max_{i}": plp.LpConstraint(
+                            e=p_sto_neg[i + 1] - p_sto_neg[i],
+                            sense=plp.LpConstraintLE,
+                            rhs=self.time_step
+                            * self.optim_conf["battery_dynamic_max"]
+                            * self.plant_conf["battery_charge_power_max"],
+                        )
+                        for i in range(n - 1)
+                    }
+                )
+                constraints.update(
+                    {
+                        f"constraint_neg_batt_dynamic_min_{i}": plp.LpConstraint(
+                            e=p_sto_neg[i + 1] - p_sto_neg[i],
+                            sense=plp.LpConstraintGE,
+                            rhs=self.time_step
+                            * self.optim_conf["battery_dynamic_min"]
+                            * self.plant_conf["battery_charge_power_max"],
+                        )
+                        for i in range(n - 1)
+                    }
+                )
             # Then the classic battery constraints
-            constraints.update({"constraint_pstopos_{}".format(i) : 
-                plp.LpConstraint(
-                    e=P_sto_pos[i] - self.plant_conf['eta_disch']*self.plant_conf['Pd_max']*E[i],
-                    sense=plp.LpConstraintLE,
-                    rhs=0)
-                for i in set_I})
-            constraints.update({"constraint_pstoneg_{}".format(i) : 
-                plp.LpConstraint(
-                    e=-P_sto_neg[i] - (1/self.plant_conf['eta_ch'])*self.plant_conf['Pc_max']*(1-E[i]),
-                    sense=plp.LpConstraintLE,
-                    rhs=0)
-                for i in set_I})
-            constraints.update({"constraint_socmax_{}".format(i) : 
-                plp.LpConstraint(
-                    e=-plp.lpSum(P_sto_pos[j]*(1/self.plant_conf['eta_disch']) + self.plant_conf['eta_ch']*P_sto_neg[j] for j in range(i)),
-                    sense=plp.LpConstraintLE,
-                    rhs=(self.plant_conf['Enom']/self.timeStep)*(self.plant_conf['SOCmax'] - soc_init))
-                for i in set_I})
-            constraints.update({"constraint_socmin_{}".format(i) : 
-                plp.LpConstraint(
-                    e=plp.lpSum(P_sto_pos[j]*(1/self.plant_conf['eta_disch']) + self.plant_conf['eta_ch']*P_sto_neg[j] for j in range(i)),
-                    sense=plp.LpConstraintLE,
-                    rhs=(self.plant_conf['Enom']/self.timeStep)*(soc_init - self.plant_conf['SOCmin']))
-                for i in set_I})
-            constraints.update({"constraint_socfinal_{}".format(0) : 
-                plp.LpConstraint(
-                    e=plp.lpSum(P_sto_pos[i]*(1/self.plant_conf['eta_disch']) + self.plant_conf['eta_ch']*P_sto_neg[i] for i in set_I),
-                    sense=plp.LpConstraintEQ,
-                    rhs=(soc_init - soc_final)*self.plant_conf['Enom']/self.timeStep)
-                })
+            constraints.update(
+                {
+                    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
+                }
+            )
+            constraints.update(
+                {
+                    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
+                }
+            )
+            constraints.update(
+                {
+                    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]
+                            for j in range(i)
+                        ),
+                        sense=plp.LpConstraintLE,
+                        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
+                }
+            )
+            constraints.update(
+                {
+                    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]
+                            for j in range(i)
+                        ),
+                        sense=plp.LpConstraintLE,
+                        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
+                }
+            )
+            constraints.update(
+                {
+                    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
+                        ),
+                        sense=plp.LpConstraintEQ,
+                        rhs=(soc_init - soc_final)
+                        * self.plant_conf["battery_nominal_energy_capacity"]
+                        / 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))
-        elif self.lp_solver == 'GLPK_CMD':
-            opt_model.solve(GLPK_CMD(msg=0))
-        elif self.lp_solver == 'COIN_CMD':
-            opt_model.solve(COIN_CMD(msg=0, path=self.lp_solver_path))
+        if self.lp_solver == "PULP_CBC_CMD":
+            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, 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,
+                    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]
@@ -661,65 +1625,130 @@ class Optimization:
             self.logger.warning("Cost function cannot be evaluated")
             return
         else:
-            self.logger.info("Total value of the Cost function = %.02f", plp.value(opt_model.objective))
+            self.logger.info(
+                "Total value of the Cost function = %.02f",
+                plp.value(opt_model.objective),
+            )
 
         # 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]
-        for k in range(self.optim_conf['num_def_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]
-        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 = [(P_sto_pos[i].varValue*(1/self.plant_conf['eta_disch']) + \
-                              self.plant_conf['eta_ch']*P_sto_neg[i].varValue)*(
-                                  self.timeStep/(self.plant_conf['Enom'])) 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
-        if self.plant_conf['inverter_is_hybrid']:
-            opt_tp["P_hybrid_inverter"] = [P_hybrid_inverter[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"] = [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[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 = [
+                (
+                    p_sto_pos[i].varValue * (1 / self.plant_conf["battery_discharge_efficiency"])
+                    + self.plant_conf["battery_charge_efficiency"] * p_sto_neg[i].varValue
+                )
+                * (self.time_step / (self.plant_conf["battery_nominal_energy_capacity"]))
+                for i in set_i
+            ]
+            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]
+            # 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.index = data_opt.index
 
         # Lets compute the optimal cost function
-        P_def_sum_tp = []
-        for i in set_I:
-            P_def_sum_tp.append(sum(P_deferrable[k][i].varValue for k in range(self.optim_conf['num_def_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]
-        if self.optim_conf['set_total_pv_sell']:
-            opt_tp["cost_profit"] = [-0.001*self.timeStep*(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]
+        p_def_sum_tp = []
+        for i in set_i:
+            p_def_sum_tp.append(
+                sum(
+                    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]
+        if self.optim_conf["set_total_pv_sell"]:
+            opt_tp["cost_profit"] = [
+                -0.001
+                * self.time_step
+                * (
+                    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
+            ]
         else:
-            opt_tp["cost_profit"] = [-0.001*self.timeStep*(unit_load_cost[i]*P_grid_pos[i].varValue + \
-                unit_prod_price[i]*P_grid_neg[i].varValue) for i in set_I]
+            opt_tp["cost_profit"] = [
+                -0.001
+                * self.time_step
+                * (
+                    unit_load_cost[i] * p_grid_pos[i].varValue
+                    + unit_prod_price[i] * p_grid_neg[i].varValue
+                )
+                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*(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]
+        if self.costfun == "profit":
+            if self.optim_conf["set_total_pv_sell"]:
+                opt_tp["cost_fun_profit"] = [
+                    -0.001
+                    * self.time_step
+                    * (
+                        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
+                ]
             else:
-                opt_tp["cost_fun_profit"] = [-0.001*self.timeStep*(unit_load_cost[i]*P_grid_pos[i].varValue + \
-                    unit_prod_price[i]*P_grid_neg[i].varValue) 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]
+                opt_tp["cost_fun_profit"] = [
+                    -0.001
+                    * self.time_step
+                    * (
+                        unit_load_cost[i] * p_grid_pos[i].varValue
+                        + unit_prod_price[i] * p_grid_neg[i].varValue
+                    )
+                    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.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]
-        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]
-            elif type_self_conso == 'bigm':
-                opt_tp["cost_fun_selfcons"] = [-0.001*self.timeStep*(unit_load_cost[i]*P_grid_pos[i].varValue + \
-                    unit_prod_price[i]*P_grid_neg[i].varValue) for i in set_I]
+                opt_tp["cost_fun_cost"] = [
+                    -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.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.time_step
+                    * (
+                        unit_load_cost[i] * p_grid_pos[i].varValue
+                        + unit_prod_price[i] * p_grid_neg[i].varValue
+                    )
+                    for i in set_i
+                ]
         else:
             self.logger.error("The cost function specified type is not valid")
 
@@ -728,19 +1757,67 @@ class Optimization:
 
         # Debug variables
         if debug:
-            for k in range(self.optim_conf["num_def_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]
+            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]
+
         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 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"], index=opt_tp.index)
+            opt_tp[f"predicted_temp_heater{i}"] = pd.Series(
+                [
+                    round(pt.value(), 2) if isinstance(pt, plp.LpAffineExpression) else pt
+                    for pt in predicted_temp
+                ],
+                index=opt_tp.index,
+            )
+            # 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(self, df_input_data: pd.DataFrame, days_list: pd.date_range) -> pd.DataFrame:
+    def perform_perfect_forecast_optim(
+        self, df_input_data: pd.DataFrame, days_list: pd.date_range
+    ) -> 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
@@ -753,21 +1830,47 @@ class Optimization:
 
         """
         self.logger.info("Perform optimization for perfect forecast scenario")
-        self.days_list_tz = days_list.tz_convert(self.time_zone).round(self.freq)[:-1] # Converted to tz and without the current day (today)
+        self.days_list_tz = days_list.tz_convert(self.time_zone).round(self.freq)[
+            :-1
+        ]  # Converted to tz and without the current day (today)
         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))
+            self.logger.info(
+                "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
-            unit_load_cost = data_tp[self.var_load_cost].values # €/kWh
-            unit_prod_price = data_tp[self.var_prod_price].values # €/kWh
+            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)
+            opt_tp = self.perform_optimization(
+                data_tp, p_pv, p_load, unit_load_cost, unit_prod_price
+            )
             if len(self.opt_res) == 0:
                 self.opt_res = opt_tp
             else:
@@ -775,52 +1878,65 @@ 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) -> pd.DataFrame:
+    def perform_dayahead_forecast_optim(
+        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
 
         """
         self.logger.info("Perform optimization for the day-ahead")
-        unit_load_cost = df_input_data[self.var_load_cost].values # €/kWh
-        unit_prod_price = df_input_data[self.var_prod_price].values # €/kWh
+        unit_load_cost = df_input_data[self.var_load_cost].values  # €/kWh
+        unit_prod_price = df_input_data[self.var_prod_price].values  # €/kWh
         # Call optimization function
-        self.opt_res = self.perform_optimization(df_input_data, P_PV.values.ravel(), 
-                                                 P_load.values.ravel(), 
-                                                 unit_load_cost, unit_prod_price)
+        self.opt_res = self.perform_optimization(
+            df_input_data,
+            p_pv.values.ravel(),
+            p_load.values.ravel(),
+            unit_load_cost,
+            unit_prod_price,
+        )
         return self.opt_res
 
-    def perform_naive_mpc_optim(self, df_input_data: pd.DataFrame, 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) -> pd.DataFrame:
+    def perform_naive_mpc_optim(
+        self,
+        df_input_data: pd.DataFrame,
+        p_pv: pd.Series,
+        p_load: pd.Series,
+        prediction_horizon: int,
+        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
@@ -829,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
@@ -843,24 +1962,39 @@ class Optimization:
         """
         self.logger.info("Perform an iteration of a naive MPC controller")
         if prediction_horizon < 5:
-            self.logger.error("Set the MPC prediction horizon to at least 5 times the optimization time step")
+            self.logger.error(
+                "Set the MPC prediction horizon to at least 5 times the optimization time step"
+            )
             return pd.DataFrame()
         else:
-            df_input_data = copy.deepcopy(df_input_data)[df_input_data.index[0]:df_input_data.index[prediction_horizon-1]]
-        unit_load_cost = df_input_data[self.var_load_cost].values # €/kWh
-        unit_prod_price = df_input_data[self.var_prod_price].values # €/kWh
+            df_input_data = copy.deepcopy(df_input_data)[
+                df_input_data.index[0] : df_input_data.index[prediction_horizon - 1]
+            ]
+        unit_load_cost = df_input_data[self.var_load_cost].values  # €/kWh
+        unit_prod_price = df_input_data[self.var_prod_price].values  # €/kWh
         # Call optimization function
-        self.opt_res = self.perform_optimization(df_input_data, 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_start_timestep=def_start_timestep, def_end_timestep=def_end_timestep)
+        self.opt_res = self.perform_optimization(
+            df_input_data,
+            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,
+        )
         return self.opt_res
 
     @staticmethod
-    def validate_def_timewindow(start: int, end: int, min_steps: int, window: int) -> Tuple[int,int,str]:
+    def validate_def_timewindow(
+        start: int, end: int, min_steps: int, window: int
+    ) -> tuple[int, int, str]:
         r"""
         Helper function to validate (and if necessary: correct) the defined optimization window of a deferrable load.
-        
+
         :param start: Start timestep of the optimization window of the deferrable load
         :type start: int
         :param end: End timestep of the optimization window of the deferrable load
@@ -887,7 +2021,7 @@ class Optimization:
             end_validated = max(0, min(window, end))
             if end_validated > 0:
                 # If the available timeframe is shorter than the number of timesteps needed to meet the hours to operate (def_total_hours), issue a warning.
-                if (end_validated-start_validated) < min_steps:
+                if (end_validated - start_validated) < min_steps:
                     warning = "Available timeframe is shorter than the specified number of hours to operate. Optimization will fail."
         else:
             warning = "Invalid timeframe for deferrable load (start timestep is not <= end timestep). Continuing optimization without timewindow constraint."