emhass 0.10.2__tar.gz → 0.10.4__tar.gz

{emhass-0.10.2 → emhass-0.10.4}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 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
+- Improved documentation
+
 ## 0.10.2 - 2024-07-06
 ### Improvement
 - Weather forecast caching and Solcast method fix by @GeoDerp

{emhass-0.10.2 → emhass-0.10.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: emhass
-Version: 0.10.2
+Version: 0.10.4
 Summary: An Energy Management System for Home Assistant
 Home-page: https://github.com/davidusb-geek/emhass
 Author: David HERNANDEZ
@@ -122,7 +122,7 @@ Installation instructions and example Home Assistant automation configurations a
 
 You must follow these steps to make EMHASS work properly:
 
-1) Define all the parameters in the configuration file according to your installation. See the description for each parameter in the **configuration** section.
+1) Define all the parameters in the configuration file according to your installation method. For the add-on method you need to use the configuration pane directly on the add-on page. For other installation methods it should be needed to set the variables using the `config_emhass.yaml` file. See below for details on the installation methods. See the description for each parameter in the **configuration** section. If you have a PV installation then this dedicated webapp can be useful to find your inverter and solar panel models: [https://emhass-pvlib-database.streamlit.app/](https://emhass-pvlib-database.streamlit.app/)
 
 2) You most notably will need to define the main data entering EMHASS. This will be the `sensor.power_photovoltaics` for the name of the your hass variable containing the PV produced power and the variable `sensor.power_load_no_var_loads` for the load power of your household excluding the power of the deferrable loads that you want to optimize.
 

{emhass-0.10.2 → emhass-0.10.4}/README.md

@@ -87,7 +87,7 @@ Installation instructions and example Home Assistant automation configurations a
 
 You must follow these steps to make EMHASS work properly:
 
-1) Define all the parameters in the configuration file according to your installation. See the description for each parameter in the **configuration** section.
+1) Define all the parameters in the configuration file according to your installation method. For the add-on method you need to use the configuration pane directly on the add-on page. For other installation methods it should be needed to set the variables using the `config_emhass.yaml` file. See below for details on the installation methods. See the description for each parameter in the **configuration** section. If you have a PV installation then this dedicated webapp can be useful to find your inverter and solar panel models: [https://emhass-pvlib-database.streamlit.app/](https://emhass-pvlib-database.streamlit.app/)
 
 2) You most notably will need to define the main data entering EMHASS. This will be the `sensor.power_photovoltaics` for the name of the your hass variable containing the PV produced power and the variable `sensor.power_load_no_var_loads` for the load power of your household excluding the power of the deferrable loads that you want to optimize.
 

{emhass-0.10.2 → emhass-0.10.4}/setup.py

@@ -19,7 +19,7 @@ long_description = (here / 'README.md').read_text(encoding='utf-8')
 
 setup(
     name='emhass',  # Required
-    version='0.10.2',  # Required
+    version='0.10.4',  # 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.2 → emhass-0.10.4}/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:

{emhass-0.10.2 → emhass-0.10.4}/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.2 → emhass-0.10.4}/src/emhass/utils.py

@@ -285,16 +285,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 +293,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 +377,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 +392,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 +436,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 +460,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"]
@@ -807,6 +798,10 @@ def build_params(params: dict, params_secrets: dict, options: dict, addon: int,
             params["optim_conf"]["def_total_hours"] = [i["operating_hours_of_each_deferrable_load"] for i in options.get("list_operating_hours_of_each_deferrable_load")]
         if options.get("list_treat_deferrable_load_as_semi_cont", None) != None:
             params["optim_conf"]["treat_def_as_semi_cont"] = [i["treat_deferrable_load_as_semi_cont"] for i in options.get("list_treat_deferrable_load_as_semi_cont")]
+        if options.get("list_set_deferrable_load_single_constant", None) != None:
+            params["optim_conf"]["set_def_constant"] = [i["set_deferrable_load_single_constant"] for i in options.get("list_set_deferrable_load_single_constant")]
+        if options.get("list_set_deferrable_startup_penalty", None) != None:
+            params["optim_conf"]["def_start_penalty"] = [i["set_deferrable_startup_penalty"] for i in options.get("list_set_deferrable_startup_penalty")]
         params["optim_conf"]["weather_forecast_method"] = options.get("weather_forecast_method", params["optim_conf"]["weather_forecast_method"])
         # Update optional param secrets
         if params["optim_conf"]["weather_forecast_method"] == "solcast":
@@ -817,12 +812,6 @@ def build_params(params: dict, params_secrets: dict, options: dict, addon: int,
         params["optim_conf"]["load_forecast_method"] = options.get("load_forecast_method", params["optim_conf"]["load_forecast_method"])
         params["optim_conf"]["delta_forecast"] = options.get("delta_forecast_daily", params["optim_conf"]["delta_forecast"])
         params["optim_conf"]["load_cost_forecast_method"] = options.get("load_cost_forecast_method", params["optim_conf"]["load_cost_forecast_method"])
-        if options.get("list_set_deferrable_load_single_constant", None) != None:
-            params["optim_conf"]["set_def_constant"] = [i["set_deferrable_load_single_constant"] for i in options.get("list_set_deferrable_load_single_constant")]
-        
-        if options.get("list_set_deferrable_startup_penalty", None) != None:
-            params["optim_conf"]["def_start_penalty"] = [i["set_deferrable_startup_penalty"] for i in options.get("list_set_deferrable_startup_penalty")]
-        
         if (options.get("list_peak_hours_periods_start_hours", None) != None and options.get("list_peak_hours_periods_end_hours", None) != None):
             start_hours_list = [i["peak_hours_periods_start_hours"] for i in options["list_peak_hours_periods_start_hours"]]
             end_hours_list = [i["peak_hours_periods_end_hours"] for i in options["list_peak_hours_periods_end_hours"]]
@@ -889,7 +878,12 @@ def build_params(params: dict, params_secrets: dict, options: dict, addon: int,
         if params['optim_conf']['num_def_loads'] is not len(params['optim_conf']['treat_def_as_semi_cont']):
             logger.warning("treat_def_as_semi_cont / list_treat_deferrable_load_as_semi_cont does not match number in num_def_loads, adding default values to parameter")
             for x in range(len(params['optim_conf']['treat_def_as_semi_cont']), params['optim_conf']['num_def_loads']):
-                params['optim_conf']['treat_def_as_semi_cont'].append(True)        
+                params['optim_conf']['treat_def_as_semi_cont'].append(True)   
+        if params['optim_conf']['num_def_loads'] is not len(params['optim_conf']['def_start_penalty']):
+            logger.warning("def_start_penalty / list_set_deferrable_startup_penalty does not match number in num_def_loads, adding default values to parameter")
+            for x in range(len(params['optim_conf']['def_start_penalty']), params['optim_conf']['num_def_loads']):
+                params['optim_conf']['def_start_penalty'].append(0.0)            
+        # days_to_retrieve should be no less then 2     
         if params['optim_conf']['num_def_loads'] is not len(params['optim_conf']['def_total_hours']):
             logger.warning("def_total_hours / list_operating_hours_of_each_deferrable_load does not match number in num_def_loads, adding default values to parameter")
             for x in range(len(params['optim_conf']['def_total_hours']), params['optim_conf']['num_def_loads']):
@@ -949,7 +943,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.2 → emhass-0.10.4}/src/emhass.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: emhass
-Version: 0.10.2
+Version: 0.10.4
 Summary: An Energy Management System for Home Assistant
 Home-page: https://github.com/davidusb-geek/emhass
 Author: David HERNANDEZ
@@ -122,7 +122,7 @@ Installation instructions and example Home Assistant automation configurations a
 
 You must follow these steps to make EMHASS work properly:
 
-1) Define all the parameters in the configuration file according to your installation. See the description for each parameter in the **configuration** section.
+1) Define all the parameters in the configuration file according to your installation method. For the add-on method you need to use the configuration pane directly on the add-on page. For other installation methods it should be needed to set the variables using the `config_emhass.yaml` file. See below for details on the installation methods. See the description for each parameter in the **configuration** section. If you have a PV installation then this dedicated webapp can be useful to find your inverter and solar panel models: [https://emhass-pvlib-database.streamlit.app/](https://emhass-pvlib-database.streamlit.app/)
 
 2) You most notably will need to define the main data entering EMHASS. This will be the `sensor.power_photovoltaics` for the name of the your hass variable containing the PV produced power and the variable `sensor.power_load_no_var_loads` for the load power of your household excluding the power of the deferrable loads that you want to optimize.
 

{emhass-0.10.2 → emhass-0.10.4}/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]