emhass 0.10.3__tar.gz → 0.10.5__tar.gz

{emhass-0.10.3 → emhass-0.10.5}/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.10.5 - 2024-07-12
+### Improvement
+- Added support for pubishing thermal load data, namely the predicted room temperature
+
+## 0.10.4 - 2024-07-10
+### Improvement
+- Added a new thermal modeling, see the new section in the documentation for help to implement this of model for thermal deferrable loads
+- Improved documentation
+
 ## 0.10.3 - 2024-07-06
 ### Improvement
 - Added improved support for `def_start_penalty` option

{emhass-0.10.3 → emhass-0.10.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: emhass
-Version: 0.10.3
+Version: 0.10.5
 Summary: An Energy Management System for Home Assistant
 Home-page: https://github.com/davidusb-geek/emhass
 Author: David HERNANDEZ

{emhass-0.10.3 → emhass-0.10.5}/setup.py

@@ -19,7 +19,7 @@ long_description = (here / 'README.md').read_text(encoding='utf-8')
 
 setup(
     name='emhass',  # Required
-    version='0.10.3',  # Required
+    version='0.10.5',  # Required
     description='An Energy Management System for Home Assistant',  # Optional
     long_description=long_description,  # Optional
     long_description_content_type='text/markdown',  # Optional (see note above)

{emhass-0.10.3 → emhass-0.10.5}/src/emhass/command_line.py

@@ -291,7 +291,6 @@ def weather_forecast_cache(emhass_conf: dict, params: str,
 
     return True
 
-
 def perfect_forecast_optim(input_data_dict: dict, logger: logging.Logger,
                            save_data_to_file: Optional[bool] = True, 
                            debug: Optional[bool] = False) -> pd.DataFrame:
@@ -334,8 +333,6 @@ def perfect_forecast_optim(input_data_dict: dict, logger: logging.Logger,
     if not debug:
         opt_res.to_csv(
             input_data_dict['emhass_conf']['data_path'] / filename, index_label='timestamp')
-        
-
     if not isinstance(input_data_dict["params"],dict):
         params = json.loads(input_data_dict["params"])
     else:
@@ -348,7 +345,6 @@ def perfect_forecast_optim(input_data_dict: dict, logger: logging.Logger,
 
     return opt_res
 
-
 def dayahead_forecast_optim(input_data_dict: dict, logger: logging.Logger, 
                             save_data_to_file: Optional[bool] = False, 
                             debug: Optional[bool] = False) -> pd.DataFrame:
@@ -379,6 +375,9 @@ def dayahead_forecast_optim(input_data_dict: dict, logger: logging.Logger,
         method=input_data_dict['fcst'].optim_conf['prod_price_forecast_method'])
     if isinstance(df_input_data_dayahead, bool) and not df_input_data_dayahead:
         return False
+    if "outdoor_temperature_forecast" in input_data_dict["params"]["passed_data"]:
+        df_input_data_dayahead["outdoor_temperature_forecast"] = \
+            input_data_dict["params"]["passed_data"]["outdoor_temperature_forecast"]
     opt_res_dayahead = input_data_dict['opt'].perform_dayahead_forecast_optim(
         df_input_data_dayahead, input_data_dict['P_PV_forecast'], input_data_dict['P_load_forecast'])
     # Save CSV file for publish_data
@@ -397,7 +396,6 @@ def dayahead_forecast_optim(input_data_dict: dict, logger: logging.Logger,
         params = json.loads(input_data_dict["params"])
     else:
         params = input_data_dict["params"]
-
     
     # if continual_publish, save day_ahead results to data_path/entities json
     if input_data_dict["retrieve_hass_conf"].get("continual_publish",False) or params["passed_data"].get("entity_save",False):
@@ -406,7 +404,6 @@ def dayahead_forecast_optim(input_data_dict: dict, logger: logging.Logger,
         
     return opt_res_dayahead
 
-
 def naive_mpc_optim(input_data_dict: dict, logger: logging.Logger, 
                     save_data_to_file: Optional[bool] = False, 
                     debug: Optional[bool] = False) -> pd.DataFrame:
@@ -436,6 +433,9 @@ def naive_mpc_optim(input_data_dict: dict, logger: logging.Logger,
         df_input_data_dayahead, method=input_data_dict['fcst'].optim_conf['prod_price_forecast_method'])
     if isinstance(df_input_data_dayahead, bool) and not df_input_data_dayahead:
         return False
+    if "outdoor_temperature_forecast" in input_data_dict["params"]["passed_data"]:
+        df_input_data_dayahead["outdoor_temperature_forecast"] = \
+            input_data_dict["params"]["passed_data"]["outdoor_temperature_forecast"]
     # The specifics params for the MPC at runtime
     prediction_horizon = input_data_dict["params"]["passed_data"]["prediction_horizon"]
     soc_init = input_data_dict["params"]["passed_data"]["soc_init"]
@@ -471,7 +471,6 @@ def naive_mpc_optim(input_data_dict: dict, logger: logging.Logger,
 
     return opt_res_naive_mpc
 
-
 def forecast_model_fit(input_data_dict: dict, logger: logging.Logger, 
                        debug: Optional[bool] = False) -> Tuple[pd.DataFrame, pd.DataFrame, MLForecaster]:
     """Perform a forecast model fit from training data retrieved from Home Assistant.
@@ -507,7 +506,6 @@ def forecast_model_fit(input_data_dict: dict, logger: logging.Logger,
             pickle.dump(mlf, outp, pickle.HIGHEST_PROTOCOL)
     return df_pred, df_pred_backtest, mlf
 
-
 def forecast_model_predict(input_data_dict: dict, logger: logging.Logger, 
                            use_last_window: Optional[bool] = True, 
                            debug: Optional[bool] = False, mlf: Optional[MLForecaster] = None
@@ -585,7 +583,6 @@ def forecast_model_predict(input_data_dict: dict, logger: logging.Logger,
             type_var="mlforecaster", publish_prefix=publish_prefix)
     return predictions
 
-
 def forecast_model_tune(input_data_dict: dict, logger: logging.Logger, 
                         debug: Optional[bool] = False, mlf: Optional[MLForecaster] = None
                         ) -> Tuple[pd.DataFrame, MLForecaster]:
@@ -626,7 +623,6 @@ def forecast_model_tune(input_data_dict: dict, logger: logging.Logger,
             pickle.dump(mlf, outp, pickle.HIGHEST_PROTOCOL)
     return df_pred_optim, mlf
 
-
 def regressor_model_fit(input_data_dict: dict, logger: logging.Logger, 
                         debug: Optional[bool] = False) -> MLRegressor:
     """Perform a forecast model fit from training data retrieved from Home Assistant.
@@ -681,7 +677,6 @@ def regressor_model_fit(input_data_dict: dict, logger: logging.Logger,
             pickle.dump(mlr, outp, pickle.HIGHEST_PROTOCOL)
     return mlr
 
-
 def regressor_model_predict(input_data_dict: dict, logger: logging.Logger, 
                             debug: Optional[bool] = False, mlr: Optional[MLRegressor] = None
                             ) -> np.ndarray:
@@ -901,6 +896,25 @@ def publish_data(input_data_dict: dict, logger: logging.Logger,
                 dont_post=dont_post
             )
             cols_published = cols_published + ["P_deferrable{}".format(k)]
+    # Publish thermal model data (predicted temperature)
+    custom_predicted_temperature_id = params["passed_data"][
+        "custom_predicted_temperature_id"
+    ]
+    for k in range(input_data_dict["opt"].optim_conf["num_def_loads"]):
+        if "def_load_config" in input_data_dict["opt"].optim_conf.keys():
+            if "thermal_config" in input_data_dict["opt"].optim_conf["def_load_config"][k]:
+                input_data_dict["rh"].post_data(
+                    opt_res_latest["P_deferrable{}".format(k)],
+                    idx_closest,
+                    custom_predicted_temperature_id[k]["entity_id"],
+                    custom_predicted_temperature_id[k]["unit_of_measurement"],
+                    custom_predicted_temperature_id[k]["friendly_name"],
+                    type_var="temperature",
+                    publish_prefix=publish_prefix,
+                    save_entities=entity_save,
+                    dont_post=dont_post
+                )
+                cols_published = cols_published + ["predicted_temp_heater{}".format(k)]
     # Publish battery power
     if input_data_dict["opt"].optim_conf["set_use_battery"]:
         if "P_batt" not in opt_res_latest.columns:
@@ -972,18 +986,19 @@ def publish_data(input_data_dict: dict, logger: logging.Logger,
         logger.warning(
             "no optim_status in opt_res_latest, run an optimization task first",
         )
-    input_data_dict["rh"].post_data(
-        opt_res_latest["optim_status"],
-        idx_closest,
-        custom_cost_fun_id["entity_id"],
-        custom_cost_fun_id["unit_of_measurement"],
-        custom_cost_fun_id["friendly_name"],
-        type_var="optim_status",
-        publish_prefix=publish_prefix,
-        save_entities=entity_save,
-        dont_post=dont_post
-    )
-    cols_published = cols_published + ["optim_status"]
+    else:
+        input_data_dict["rh"].post_data(
+            opt_res_latest["optim_status"],
+            idx_closest,
+            custom_cost_fun_id["entity_id"],
+            custom_cost_fun_id["unit_of_measurement"],
+            custom_cost_fun_id["friendly_name"],
+            type_var="optim_status",
+            publish_prefix=publish_prefix,
+            save_entities=entity_save,
+            dont_post=dont_post
+        )
+        cols_published = cols_published + ["optim_status"]
     # Publish unit_load_cost
     custom_unit_load_cost_id = params["passed_data"]["custom_unit_load_cost_id"]
     input_data_dict["rh"].post_data(

{emhass-0.10.3 → emhass-0.10.5}/src/emhass/optimization.py

@@ -103,9 +103,9 @@ class Optimization:
         r"""
         Perform the actual optimization using linear programming (LP).
         
-        :param data_tp: A DataFrame containing the input data. The results of the \
+        :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_tp: pd.DataFrame
+        :type data_opt: pd.DataFrame
         :param P_PV: The photovoltaic power values. This can be real historical \
             values or forecasted values.
         :type P_PV: numpy.array
@@ -327,47 +327,6 @@ class Optimization:
                         sense = plp.LpConstraintLE,
                         rhs = 0)
                     for i in set_I})
-            
-        # Constraint for sequence of deferrable
-        # WARNING: This is experimental, formulation seems correct but feasibility problems.
-        # Probably uncomptabile with other constraints
-        for k in range(self.optim_conf['num_def_loads']):
-            if type(self.optim_conf['P_deferrable_nom'][k]) == list:
-                power_sequence = self.optim_conf['P_deferrable_nom'][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])
-                    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})
-                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})
 
         # Two special constraints just for a self-consumption cost function
         if self.costfun == 'self-consumption':
@@ -400,128 +359,215 @@ class Optimization:
             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:
-                continue
-            else:
-                # Total time of deferrable load
-                constraints.update({"constraint_defload{}_energy".format(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]
+                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])
+                    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(P_deferrable[k][i]*self.timeStep for i in set_I),
+                        e = plp.lpSum(y[i] for i in range(len(matrix))) - 1,
                         sense = plp.LpConstraintEQ,
-                        rhs = def_total_hours[k]*self.optim_conf['P_deferrable_nom'][k])
+                        rhs = 0)
                     })
-                # 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) :
+                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 = plp.lpSum(P_deferrable[k][i]*self.timeStep for i in range(0, def_start)),
+                            e = P_deferrable[k][i] - mat[i]*y[num],
                             sense = plp.LpConstraintEQ,
                             rhs = 0)
-                        })
-                if def_end > 0:                    
-                    constraints.update({"constraint_defload{}_end_timestep".format(k) :
+                        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"]
+                        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],
+                                    )
+                                })
+                        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 range(def_end, n)),
+                            e = plp.lpSum(P_deferrable[k][i]*self.timeStep for i in set_I),
                             sense = plp.LpConstraintEQ,
-                            rhs = 0)
+                            rhs = def_total_hours[k]*self.optim_conf['P_deferrable_nom'][k])
                         })
-                # 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],
-                            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],
-                            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)
-                #     })
-                # 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):
-                    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): 
+                
+            # 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=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): 
+                        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=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): 
+                        e = plp.lpSum(P_deferrable[k][i]*self.timeStep for i in range(def_end, n)),
+                        sense = plp.LpConstraintEQ,
+                        rhs = 0)
+                    })
+                
+            # 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):
+                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
+            # 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_def_start[k][i]
-                        - P_def_bin2[k][i]
-                        + (P_def_bin2[k][i - 1] if i - 1 >= 0 else current_state),
+                        e=P_deferrable[k][i] - self.optim_conf['P_deferrable_nom'][k]*P_def_bin1[k][i],
                         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):
+                constraints.update({"constraint_pdef{}_semicont2_{}".format(k, i) :
                     plp.LpConstraint(
-                        e=(P_def_bin2[k][i-1] if i-1 >= 0 else 0) + P_def_start[k][i],
+                        e=P_deferrable[k][i] - self.optim_conf['P_deferrable_nom'][k]*P_def_bin1[k][i],
                         sense=plp.LpConstraintLE,
-                        rhs=1)
+                        rhs=0)
                     for i in set_I})
-                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 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)
+            #     })
 
         # The battery constraints
         if self.optim_conf['set_use_battery']:
@@ -685,6 +731,9 @@ class Optimization:
             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 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)
 
         return opt_tp
 

{emhass-0.10.3 → emhass-0.10.5}/src/emhass/retrieve_hass.py

@@ -370,6 +370,9 @@ class RetrieveHass:
         elif type_var == "deferrable":
             data = RetrieveHass.get_attr_data_dict(data_df, idx, entity_id, unit_of_measurement,
                                                    friendly_name, "deferrables_schedule", state)
+        elif type_var == "temperature":
+            data = RetrieveHass.get_attr_data_dict(data_df, idx, entity_id, unit_of_measurement,
+                                                   friendly_name, "predicted_temperatures", state)
         elif type_var == "batt":
             data = RetrieveHass.get_attr_data_dict(data_df, idx, entity_id, unit_of_measurement,
                                                    friendly_name, "battery_scheduled_power", state)

{emhass-0.10.3 → emhass-0.10.5}/src/emhass/utils.py

@@ -143,6 +143,7 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
         params = {}
     # Some default data needed
     custom_deferrable_forecast_id = []
+    custom_predicted_temperature_id = []
     for k in range(optim_conf["num_def_loads"]):
         custom_deferrable_forecast_id.append(
             {
@@ -151,6 +152,13 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
                 "friendly_name": "Deferrable Load {}".format(k),
             }
         )
+        custom_predicted_temperature_id.append(
+            {
+                "entity_id": "sensor.temp_predicted{}".format(k),
+                "unit_of_measurement": "°C",
+                "friendly_name": "Predicted temperature {}".format(k),
+            }
+        )
     default_passed_dict = {
         "custom_pv_forecast_id": {
             "entity_id": "sensor.p_pv_forecast",
@@ -208,6 +216,7 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
             "friendly_name": "Unit Prod Price",
         },
         "custom_deferrable_forecast_id": custom_deferrable_forecast_id,
+        "custom_predicted_temperature_id": custom_predicted_temperature_id,
         "publish_prefix": "",
     }
     if "passed_data" in params.keys():
@@ -285,16 +294,6 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
             else:
                 def_end_timestep = runtimeparams["def_end_timestep"]
             params["passed_data"]["def_end_timestep"] = def_end_timestep
-            if "alpha" not in runtimeparams.keys():
-                alpha = 0.5
-            else:
-                alpha = runtimeparams["alpha"]
-            params["passed_data"]["alpha"] = alpha
-            if "beta" not in runtimeparams.keys():
-                beta = 0.5
-            else:
-                beta = runtimeparams["beta"]
-            params["passed_data"]["beta"] = beta
             forecast_dates = copy.deepcopy(forecast_dates)[0:prediction_horizon]
         else:
             params["passed_data"]["prediction_horizon"] = None
@@ -303,11 +302,9 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
             params["passed_data"]["def_total_hours"] = None
             params["passed_data"]["def_start_timestep"] = None
             params["passed_data"]["def_end_timestep"] = None
-            params["passed_data"]["alpha"] = None
-            params["passed_data"]["beta"] = None
         # Treat passed forecast data lists
-        list_forecast_key = ['pv_power_forecast', 'load_power_forecast', 'load_cost_forecast', 'prod_price_forecast']
-        forecast_methods = ['weather_forecast_method', 'load_forecast_method', 'load_cost_forecast_method', 'prod_price_forecast_method']
+        list_forecast_key = ['pv_power_forecast', 'load_power_forecast', 'load_cost_forecast', 'prod_price_forecast', 'outdoor_temperature_forecast']
+        forecast_methods = ['weather_forecast_method', 'load_forecast_method', 'load_cost_forecast_method', 'prod_price_forecast_method', 'outdoor_temperature_forecast_method']
         # Param to save forecast cache (i.e. Solcast)
         if "weather_forecast_cache" not in runtimeparams.keys():
             weather_forecast_cache = False
@@ -389,19 +386,13 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
         if "model_predict_unit_of_measurement" not in runtimeparams.keys():
             model_predict_unit_of_measurement = "W"
         else:
-            model_predict_unit_of_measurement = runtimeparams[
-                "model_predict_unit_of_measurement"
-            ]
-        params["passed_data"][
-            "model_predict_unit_of_measurement"
-        ] = model_predict_unit_of_measurement
+            model_predict_unit_of_measurement = runtimeparams["model_predict_unit_of_measurement"]
+        params["passed_data"]["model_predict_unit_of_measurement"] = model_predict_unit_of_measurement
         if "model_predict_friendly_name" not in runtimeparams.keys():
             model_predict_friendly_name = "Load Power Forecast custom ML model"
         else:
             model_predict_friendly_name = runtimeparams["model_predict_friendly_name"]
-        params["passed_data"][
-            "model_predict_friendly_name"
-        ] = model_predict_friendly_name
+        params["passed_data"]["model_predict_friendly_name"] = model_predict_friendly_name
         if "mlr_predict_entity_id" not in runtimeparams.keys():
             mlr_predict_entity_id = "sensor.mlr_predict"
         else:
@@ -410,17 +401,24 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
         if "mlr_predict_unit_of_measurement" not in runtimeparams.keys():
             mlr_predict_unit_of_measurement = None
         else:
-            mlr_predict_unit_of_measurement = runtimeparams[
-                "mlr_predict_unit_of_measurement"
-            ]
-        params["passed_data"][
-            "mlr_predict_unit_of_measurement"
-        ] = mlr_predict_unit_of_measurement
+            mlr_predict_unit_of_measurement = runtimeparams["mlr_predict_unit_of_measurement"]
+        params["passed_data"]["mlr_predict_unit_of_measurement"] = mlr_predict_unit_of_measurement
         if "mlr_predict_friendly_name" not in runtimeparams.keys():
             mlr_predict_friendly_name = "mlr predictor"
         else:
             mlr_predict_friendly_name = runtimeparams["mlr_predict_friendly_name"]
         params["passed_data"]["mlr_predict_friendly_name"] = mlr_predict_friendly_name
+        # Treat passed data for other parameters
+        if "alpha" not in runtimeparams.keys():
+            alpha = 0.5
+        else:
+            alpha = runtimeparams["alpha"]
+        params["passed_data"]["alpha"] = alpha
+        if "beta" not in runtimeparams.keys():
+            beta = 0.5
+        else:
+            beta = runtimeparams["beta"]
+        params["passed_data"]["beta"] = beta
         # Treat optimization configuration parameters passed at runtime
         if "num_def_loads" in runtimeparams.keys():
             optim_conf["num_def_loads"] = runtimeparams["num_def_loads"]
@@ -447,6 +445,8 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
             optim_conf["def_start_penalty"] = [
                 ast.literal_eval(str(k).capitalize()) for k in runtimeparams["def_start_penalty"]
             ]
+        if 'def_load_config' in runtimeparams:
+            optim_conf["def_load_config"] = runtimeparams['def_load_config']
         if "solcast_api_key" in runtimeparams.keys():
             retrieve_hass_conf["solcast_api_key"] = runtimeparams["solcast_api_key"]
             optim_conf["weather_forecast_method"] = "solcast"
@@ -469,7 +469,7 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
         if 'freq' in runtimeparams.keys():
             retrieve_hass_conf['freq'] = pd.to_timedelta(runtimeparams['freq'], "minutes")
         if 'continual_publish' in runtimeparams.keys():
-            retrieve_hass_conf['continual_publish'] = bool(runtimeparams['continual_publish'])  
+            retrieve_hass_conf['continual_publish'] = bool(runtimeparams['continual_publish'])
         # Treat plant configuration parameters passed at runtime
         if "SOCmin" in runtimeparams.keys():
             plant_conf["SOCmin"] = runtimeparams["SOCmin"]
@@ -530,6 +530,10 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
             params["passed_data"]["custom_deferrable_forecast_id"] = runtimeparams[
                 "custom_deferrable_forecast_id"
             ]
+        if "custom_predicted_temperature_id" in runtimeparams.keys():
+            params["passed_data"]["custom_predicted_temperature_id"] = runtimeparams[
+                "custom_predicted_temperature_id"
+            ]
         # A condition to put a prefix on all published data, or check for saved data under prefix name
         if "publish_prefix" not in runtimeparams.keys():
             publish_prefix = ""
@@ -952,7 +956,8 @@ def set_df_index_freq(df: pd.DataFrame) -> pd.DataFrame:
 
     """
     idx_diff = np.diff(df.index)
+    # Sometimes there are zero values in this list.
+    idx_diff = idx_diff[np.nonzero(idx_diff)]
     sampling = pd.to_timedelta(np.median(idx_diff))
     df = df[~df.index.duplicated()]
-    df = df.asfreq(sampling)
-    return df
+    return df.asfreq(sampling)

{emhass-0.10.3 → emhass-0.10.5}/src/emhass.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: emhass
-Version: 0.10.3
+Version: 0.10.5
 Summary: An Energy Management System for Home Assistant
 Home-page: https://github.com/davidusb-geek/emhass
 Author: David HERNANDEZ

{emhass-0.10.3 → emhass-0.10.5}/tests/test_optimization.py

@@ -7,6 +7,7 @@ import pandas as pd
 import numpy as np
 import pathlib
 import pickle
+import random
 from datetime import datetime, timezone
 
 from emhass.retrieve_hass import RetrieveHass
@@ -265,20 +266,44 @@ class TestOptimization(unittest.TestCase):
             self.df_input_data_dayahead, self.P_PV_forecast, self.P_load_forecast, prediction_horizon,
             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.assertAlmostEqual(self.opt_res_dayahead.loc[self.opt_res_dayahead.index[-1],'SOC_opt'], soc_final)
+    
+    def test_thermal_load_optim(self):
+        self.df_input_data_dayahead = self.fcst.get_load_cost_forecast(self.df_input_data_dayahead)
+        self.df_input_data_dayahead = self.fcst.get_prod_price_forecast(self.df_input_data_dayahead)
+        self.df_input_data_dayahead['outdoor_temperature_forecast'] = [random.normalvariate(10.0, 3.0) for _ in range(48)]
+        runtimeparams = {
+            'def_load_config': [
+                {},
+                {'thermal_config': {
+                    'heating_rate': 5.0,
+                    'cooling_constant': 0.1,
+                    'overshoot_temperature': 24.0,
+                    'start_temperature': 20,
+                    'desired_temperatures': [21]*48,
+                    }
+                }
+            ]
+        }
+        self.optim_conf["def_load_config"] = runtimeparams['def_load_config']
+        self.opt = Optimization(self.retrieve_hass_conf, self.optim_conf, self.plant_conf, 
+                                self.fcst.var_load_cost, self.fcst.var_prod_price,  
+                                self.costfun, emhass_conf, logger)
+        unit_load_cost = self.df_input_data_dayahead[self.opt.var_load_cost].values # €/kWh
+        unit_prod_price = self.df_input_data_dayahead[self.opt.var_prod_price].values # €/kWh
+        self.opt_res_dayahead = self.opt.perform_optimization(self.df_input_data_dayahead, 
+                                                              self.P_PV_forecast.values.ravel(), 
+                                                              self.P_load_forecast.values.ravel(), 
+                                                              unit_load_cost, unit_prod_price)
+        self.assertIsInstance(self.opt_res_dayahead, type(pd.DataFrame()))
+        self.assertIsInstance(self.opt_res_dayahead.index, pd.core.indexes.datetimes.DatetimeIndex)
+        self.assertIsInstance(self.opt_res_dayahead.index.dtype, pd.core.dtypes.dtypes.DatetimeTZDtype)
+        self.assertTrue('cost_fun_'+self.costfun in self.opt_res_dayahead.columns)
+        self.assertTrue(self.opt.optim_status == 'Optimal')
         
-        
-
     def run_penalty_test_forecast(self):
-        self.opt = Optimization(
-            self.retrieve_hass_conf,
-            self.optim_conf,
-            self.plant_conf,
-            self.fcst.var_load_cost,
-            self.fcst.var_prod_price,
-            self.costfun,
-            emhass_conf,
-            logger,
-        )
+        self.opt = Optimization(self.retrieve_hass_conf, self.optim_conf, self.plant_conf,
+                                self.fcst.var_load_cost, self.fcst.var_prod_price,
+                                self.costfun, emhass_conf, logger)
         def_total_hours = [5 * self.retrieve_hass_conf["freq"].seconds / 3600.0]
         def_start_timestep = [0]
         def_end_timestep = [0]