emhass 0.10.0__py3-none-any.whl → 0.10.2__py3-none-any.whl

emhass/command_line.py

@@ -52,7 +52,7 @@ def set_input_data_dict(emhass_conf: dict, costfun: str,
     logger.info("Setting up needed data")
     # Parsing yaml
     retrieve_hass_conf, optim_conf, plant_conf = utils.get_yaml_parse(
-        emhass_conf, use_secrets=not (get_data_from_file), params=params)
+        emhass_conf, use_secrets=not(get_data_from_file), params=params)
     # Treat runtimeparams
     params, retrieve_hass_conf, optim_conf, plant_conf = utils.treat_runtimeparams(
         runtimeparams, params, retrieve_hass_conf, optim_conf, plant_conf, set_type, logger)
@@ -97,6 +97,8 @@ def set_input_data_dict(emhass_conf: dict, costfun: str,
         # Get PV and load forecasts
         df_weather = fcst.get_weather_forecast(
             method=optim_conf["weather_forecast_method"])
+        if isinstance(df_weather, bool) and not df_weather:
+            return False
         P_PV_forecast = fcst.get_power_from_weather(df_weather)
         P_load_forecast = fcst.get_load_forecast(
             method=optim_conf['load_forecast_method'])
@@ -142,6 +144,8 @@ def set_input_data_dict(emhass_conf: dict, costfun: str,
         # Get PV and load forecasts
         df_weather = fcst.get_weather_forecast(
             method=optim_conf['weather_forecast_method'])
+        if isinstance(df_weather, bool) and not df_weather:
+            return False
         P_PV_forecast = fcst.get_power_from_weather(
             df_weather, set_mix_forecast=True, df_now=df_input_data)
         P_load_forecast = fcst.get_load_forecast(
@@ -243,6 +247,50 @@ def set_input_data_dict(emhass_conf: dict, costfun: str,
     }
     return input_data_dict
 
+def weather_forecast_cache(emhass_conf: dict, params: str, 
+                   runtimeparams: str, logger: logging.Logger) -> bool:
+    """
+    Perform a call to get forecast function, intend to save results to cache.
+
+    :param emhass_conf: Dictionary containing the needed emhass paths
+    :type emhass_conf: dict
+    :param params: Configuration parameters passed from data/options.json
+    :type params: str
+    :param runtimeparams: Runtime optimization parameters passed as a dictionary
+    :type runtimeparams: str
+    :param logger: The passed logger object
+    :type logger: logging object
+    :return: A bool for function completion
+    :rtype: bool
+
+    """
+    
+    # Parsing yaml
+    retrieve_hass_conf, optim_conf, plant_conf = utils.get_yaml_parse(
+        emhass_conf, use_secrets=True, params=params)
+    
+    # Treat runtimeparams
+    params, retrieve_hass_conf, optim_conf, plant_conf = utils.treat_runtimeparams(
+        runtimeparams, params, retrieve_hass_conf, optim_conf, plant_conf, "forecast", logger)
+    
+    # Make sure weather_forecast_cache is true
+    if (params != None) and (params != "null"):
+        params = json.loads(params)
+    else:
+        params = {}
+    params["passed_data"]["weather_forecast_cache"] = True
+    params = json.dumps(params)
+
+    # Create Forecast object
+    fcst = Forecast(retrieve_hass_conf, optim_conf, plant_conf,
+                params, emhass_conf, logger)
+
+    result = fcst.get_weather_forecast(optim_conf["weather_forecast_method"])
+    if isinstance(result, bool) and not result:
+        return False
+
+    return True
+
 
 def perfect_forecast_optim(input_data_dict: dict, logger: logging.Logger,
                            save_data_to_file: Optional[bool] = True, 
@@ -683,8 +731,6 @@ def regressor_model_predict(input_data_dict: dict, logger: logging.Logger,
             type_var="mlregressor")
     return prediction
 
-
-
 def publish_data(input_data_dict: dict, logger: logging.Logger, 
                  save_data_to_file: Optional[bool] = False, 
                  opt_res_latest: Optional[pd.DataFrame] = None, 
@@ -708,12 +754,10 @@ def publish_data(input_data_dict: dict, logger: logging.Logger,
 
     """
     logger.info("Publishing data to HASS instance")
-
     if not isinstance(input_data_dict["params"],dict):
         params = json.loads(input_data_dict["params"])
     else:
         params = input_data_dict["params"]
-    
     # Check if a day ahead optimization has been performed (read CSV file)
     if save_data_to_file:
         today = datetime.now(timezone.utc).replace(
@@ -726,7 +770,6 @@ def publish_data(input_data_dict: dict, logger: logging.Logger,
         opt_res_list_names = []
         publish_prefix = params["passed_data"]["publish_prefix"]
         entity_path = input_data_dict['emhass_conf']['data_path'] / "entities"
-        
         # Check if items in entity_path
         if os.path.exists(entity_path) and len(os.listdir(entity_path)) > 0:
             # Obtain all files in entity_path
@@ -805,6 +848,36 @@ def publish_data(input_data_dict: dict, logger: logging.Logger,
         dont_post=dont_post
     )
     cols_published = ["P_PV", "P_Load"]
+    # Publish PV curtailment
+    if input_data_dict["fcst"].plant_conf['compute_curtailment']:
+        custom_pv_curtailment_id = params["passed_data"]["custom_pv_curtailment_id"]
+        input_data_dict["rh"].post_data(
+            opt_res_latest["P_PV_curtailment"],
+            idx_closest,
+            custom_pv_curtailment_id["entity_id"],
+            custom_pv_curtailment_id["unit_of_measurement"],
+            custom_pv_curtailment_id["friendly_name"],
+            type_var="power",
+            publish_prefix=publish_prefix,
+            save_entities=entity_save,
+            dont_post=dont_post
+        )
+        cols_published = cols_published + ["P_PV_curtailment"]
+    # Publish P_hybrid_inverter
+    if input_data_dict["fcst"].plant_conf['inverter_is_hybrid']:
+        custom_hybrid_inverter_id = params["passed_data"]["custom_hybrid_inverter_id"]
+        input_data_dict["rh"].post_data(
+            opt_res_latest["P_hybrid_inverter"],
+            idx_closest,
+            custom_hybrid_inverter_id["entity_id"],
+            custom_hybrid_inverter_id["unit_of_measurement"],
+            custom_hybrid_inverter_id["friendly_name"],
+            type_var="power",
+            publish_prefix=publish_prefix,
+            save_entities=entity_save,
+            dont_post=dont_post
+        )
+        cols_published = cols_published + ["P_hybrid_inverter"]
     # Publish deferrable loads
     custom_deferrable_forecast_id = params["passed_data"][
         "custom_deferrable_forecast_id"
@@ -944,7 +1017,7 @@ def publish_data(input_data_dict: dict, logger: logging.Logger,
         opt_res_latest.index[idx_closest]]]
     return opt_res
 
-def continual_publish(input_data_dict,entity_path,logger):
+def continual_publish(input_data_dict: dict, entity_path: pathlib.Path, logger: logging.Logger):
     """
     If continual_publish is true and a entity file saved in /data_path/entities, continually publish sensor on freq rate, updating entity current state value based on timestamp
 
@@ -959,23 +1032,22 @@ def continual_publish(input_data_dict,entity_path,logger):
     logger.info("Continual publish thread service started")
     freq = input_data_dict['retrieve_hass_conf'].get("freq", pd.to_timedelta(1, "minutes"))
     entity_path_contents = []
-
     while True:
         # Sleep for x seconds (using current time as a reference for time left)
         time.sleep(max(0,freq.total_seconds() - (datetime.now(input_data_dict["retrieve_hass_conf"]["time_zone"]).timestamp() % 60)))
-
         # Loop through all saved entity files
         if os.path.exists(entity_path) and len(os.listdir(entity_path)) > 0:
             entity_path_contents =  os.listdir(entity_path)    
             for entity in entity_path_contents:
                 if entity != "metadata.json":
                     # Call publish_json with entity file, build entity, and publish                     
-                    publish_json(entity,input_data_dict,entity_path,logger,"continual_publish")
+                    publish_json(entity, input_data_dict, entity_path, logger, "continual_publish")
         pass 
     # This function should never return           
     return False 
 
-def publish_json(entity,input_data_dict,entity_path,logger,reference: Optional[str] = ""):
+def publish_json(entity: dict, input_data_dict: dict, entity_path: pathlib.Path, 
+                 logger: logging.Logger, reference: Optional[str] = ""):
     """
     Extract saved entity data from .json (in data_path/entities), build entity, post results to post_data
 
@@ -989,9 +1061,8 @@ def publish_json(entity,input_data_dict,entity_path,logger,reference: Optional[s
     :type logger: logging.Logger
     :param reference: String for identifying who ran the function  
     :type reference: str, optional
-
+    
     """
-
     # Retrieve entity metadata from file
     if os.path.isfile(entity_path / "metadata.json"):
         with open(entity_path / "metadata.json", "r") as file:
@@ -1001,16 +1072,12 @@ def publish_json(entity,input_data_dict,entity_path,logger,reference: Optional[s
     else:
         logger.error("unable to located metadata.json in:" + entity_path)
         return False            
-
     # Round current timecode (now)
     now_precise = datetime.now(input_data_dict["retrieve_hass_conf"]["time_zone"]).replace(second=0, microsecond=0)
-
     # Retrieve entity data from file
     entity_data = pd.read_json(entity_path / entity , orient='index')
-    
     # Remove ".json" from string for entity_id
     entity_id = entity.replace(".json", "")
-    
     # Adjust Dataframe from received entity json file
     entity_data.columns = [metadata[entity_id]["name"]]
     entity_data.index.name = "timestamp"
@@ -1025,15 +1092,13 @@ def publish_json(entity,input_data_dict,entity_path,logger,reference: Optional[s
         idx_closest = entity_data.index.get_indexer([now_precise], method="bfill")[0]
     if idx_closest == -1:
         idx_closest = entity_data.index.get_indexer([now_precise], method="nearest")[0]
-    
     # Call post data 
     if reference == "continual_publish":
         logger.debug("Auto Published sensor:")
         logger_levels = "DEBUG"
     else: 
         logger_levels = "INFO"
-    
-    #post/save entity
+    # post/save entity
     input_data_dict["rh"].post_data(
         data_df=entity_data[metadata[entity_id]["name"]],
         idx=idx_closest,
@@ -1125,7 +1190,7 @@ def main():
         logger.error("Could not find emhass/src foulder in: " + str(root_path))
         logger.error("Try setting emhass root path with --root")
         return False
-    # Additionnal argument
+    # Additional argument
     try:
         parser.add_argument(
             "--version",

emhass/forecast.py

@@ -182,6 +182,7 @@ class Forecast(object):
         
         """
         csv_path  = self.emhass_conf['data_path'] / csv_path
+        w_forecast_cache_path = os.path.abspath(self.emhass_conf['data_path'] / "weather_forecast_data.pkl")
 
         self.logger.info("Retrieving weather forecast data using method = "+method)
         self.weather_forecast_method = method # Saving this attribute for later use to identify csv method usage
@@ -223,40 +224,97 @@ class Forecast(object):
             data['relative_humidity'] = raw_data['Relative Humidity (%)']
             data['precipitable_water'] = pvlib.atmosphere.gueymard94_pw(
                 data['temp_air'], data['relative_humidity'])
-        elif method == 'solcast': # using solcast API
-            # Retrieve data from the solcast API
-            if 'solcast_api_key' not in self.retrieve_hass_conf:
-                self.logger.warning("The solcast_api_key parameter was not defined, using dummy values for testing")
-                self.retrieve_hass_conf['solcast_api_key'] = "123456"
-            if 'solcast_rooftop_id' not in self.retrieve_hass_conf:
-                self.logger.warning("The solcast_rooftop_id parameter was not defined, using dummy values for testing")
-                self.retrieve_hass_conf['solcast_rooftop_id'] = "123456"
-            headers = {
-                "Authorization": "Bearer " + self.retrieve_hass_conf['solcast_api_key'],
-                "content-type": "application/json",
-                }
-            days_solcast = int(len(self.forecast_dates)*self.freq.seconds/3600)
-            url = "https://api.solcast.com.au/rooftop_sites/"+self.retrieve_hass_conf['solcast_rooftop_id']+"/forecasts?hours="+str(days_solcast)
-            response = get(url, headers=headers)
-            '''import bz2 # Uncomment to save a serialized data for tests
-            import _pickle as cPickle
-            with bz2.BZ2File("data/test_response_solcast_get_method.pbz2", "w") as f: 
-                cPickle.dump(response, f)'''
-            data = response.json()
-            data_list = []
-            for elm in data['forecasts']:
-                data_list.append(elm['pv_estimate']*1000) # Converting kW to W
-            # Check if the retrieved data has the correct length
-            if len(data_list) < len(self.forecast_dates):
-                self.logger.error("Not enough data retrived from SolCast service, try increasing the time step or use MPC")
+        elif method == 'solcast': # using Solcast API
+            # Check if weather_forecast_cache is true or if forecast_data file does not exist
+            if self.params["passed_data"]["weather_forecast_cache"] or not os.path.isfile(w_forecast_cache_path):
+                # Check if weather_forecast_cache_only is true, if so produce error for not finding cache file
+                if not self.params["passed_data"]["weather_forecast_cache_only"]:
+                    # Retrieve data from the Solcast API
+                    if 'solcast_api_key' not in self.retrieve_hass_conf:
+                        self.logger.error("The solcast_api_key parameter was not defined")
+                        return False
+                    if 'solcast_rooftop_id' not in self.retrieve_hass_conf:
+                        self.logger.error("The solcast_rooftop_id parameter was not defined")
+                        return False
+                    headers = {
+                        'User-Agent': 'EMHASS',
+                        "Authorization": "Bearer " + self.retrieve_hass_conf['solcast_api_key'],
+                        "content-type": "application/json",
+                        }
+                    days_solcast = int(len(self.forecast_dates)*self.freq.seconds/3600)
+                    # If weather_forecast_cache, set request days as twice as long to avoid length issues (add a buffer) 
+                    if self.params["passed_data"]["weather_forecast_cache"]:
+                        days_solcast = min((days_solcast * 2), 336)
+                    url = "https://api.solcast.com.au/rooftop_sites/"+self.retrieve_hass_conf['solcast_rooftop_id']+"/forecasts?hours="+str(days_solcast)
+                    response = get(url, headers=headers)
+                    '''import bz2 # Uncomment to save a serialized data for tests
+                    import _pickle as cPickle
+                    with bz2.BZ2File("data/test_response_solcast_get_method.pbz2", "w") as f: 
+                        cPickle.dump(response, f)'''
+                    # Verify the request passed
+                    if int(response.status_code) == 200:
+                        data = response.json()
+                    elif int(response.status_code) == 402 or int(response.status_code) == 429:
+                        self.logger.error("Solcast error: May have exceeded your subscription limit.")
+                        return False  
+                    elif int(response.status_code) >= 400 or int(response.status_code) >= 202:
+                        self.logger.error("Solcast error: There was a issue with the solcast request, check solcast API key and rooftop ID.")
+                        self.logger.error("Solcast error: Check that your subscription is valid and your network can connect to Solcast.")
+                        return False  
+                    data_list = []
+                    for elm in data['forecasts']:
+                        data_list.append(elm['pv_estimate']*1000) # Converting kW to W
+                    # Check if the retrieved data has the correct length
+                    if len(data_list) < len(self.forecast_dates):
+                        self.logger.error("Not enough data retried from Solcast service, try increasing the time step or use MPC.")
+                    else:
+                        # If runtime weather_forecast_cache is true save forecast result to file as cache
+                        if self.params["passed_data"]["weather_forecast_cache"]:
+                            # Add x2 forecast periods for cached results. This adds a extra delta_forecast amount of days for a buffer
+                            cached_forecast_dates =  self.forecast_dates.union(pd.date_range(self.forecast_dates[-1], periods=(len(self.forecast_dates) +1), freq=self.freq)[1:])
+                            cache_data_list = data_list[0:len(cached_forecast_dates)]
+                            cache_data_dict = {'ts':cached_forecast_dates, 'yhat':cache_data_list}
+                            data_cache = pd.DataFrame.from_dict(cache_data_dict)
+                            data_cache.set_index('ts', inplace=True)
+                            with open(w_forecast_cache_path, "wb") as file:    
+                                cPickle.dump(data_cache, file)
+                            if not os.path.isfile(w_forecast_cache_path):
+                                self.logger.warning("Solcast forecast data could not be saved to file.")
+                            else:
+                                self.logger.info("Saved the Solcast results to cache, for later reference.")    
+                        # Trim request results to forecast_dates        
+                        data_list = data_list[0:len(self.forecast_dates)]
+                        data_dict = {'ts':self.forecast_dates, 'yhat':data_list}
+                        # Define DataFrame
+                        data = pd.DataFrame.from_dict(data_dict)
+                        # Define index
+                        data.set_index('ts', inplace=True)
+            # Else, notify user to update cache
+                else:
+                    self.logger.error("Unable to obtain Solcast cache file.")
+                    self.logger.error("Try running optimization again with 'weather_forecast_cache_only': false")
+                    self.logger.error("Optionally, obtain new Solcast cache with runtime parameter 'weather_forecast_cache': true in an optimization, or run the `forecast-cache` action, to pull new data from Solcast and cache.")
+                    return False
+            # Else, open stored weather_forecast_data.pkl file for previous forecast data (cached data)
             else:
-                # Ensure correct length
-                data_list = data_list[0:len(self.forecast_dates)]
-                # Define DataFrame
-                data_dict = {'ts':self.forecast_dates, 'yhat':data_list}
-                data = pd.DataFrame.from_dict(data_dict)
-                # Define index
-                data.set_index('ts', inplace=True)
+                with open(w_forecast_cache_path, "rb") as file:
+                    data = cPickle.load(file)
+                    if not isinstance(data, pd.DataFrame) or len(data) < len(self.forecast_dates):
+                        self.logger.error("There has been a error obtaining cached Solcast forecast data.")
+                        self.logger.error("Try running optimization again with 'weather_forecast_cache': true, or run action `forecast-cache`, to pull new data from Solcast and cache.")
+                        self.logger.warning("Removing old Solcast cache file. Next optimization will pull data from Solcast, unless 'weather_forecast_cache_only': true")
+                        os.remove(w_forecast_cache_path)
+                        return False
+                    # Filter cached forecast data to match current forecast_dates start-end range (reduce forecast Dataframe size to appropriate length)
+                    if self.forecast_dates[0] in data.index and self.forecast_dates[-1] in data.index:
+                        data = data.loc[self.forecast_dates[0]:self.forecast_dates[-1]]
+                        self.logger.info("Retrieved Solcast data from the previously saved cache.")
+                    else:
+                        self.logger.error("Unable to obtain cached Solcast forecast data within the requested timeframe range.")
+                        self.logger.error("Try running optimization again (not using cache). Optionally, add runtime parameter 'weather_forecast_cache': true to pull new data from Solcast and cache.")
+                        self.logger.warning("Removing old Solcast cache file. Next optimization will pull data from Solcast, unless 'weather_forecast_cache_only': true")
+                        os.remove(w_forecast_cache_path)
+                        return False    
         elif method == 'solar.forecast': # using the solar.forecast API
             # Retrieve data from the solar.forecast API
             if 'solar_forecast_kwp' not in self.retrieve_hass_conf:
@@ -423,9 +481,9 @@ class Forecast(object):
                 # Setting the main parameters of the PV plant
                 location = Location(latitude=self.lat, longitude=self.lon)
                 temp_params = TEMPERATURE_MODEL_PARAMETERS['sapm']['close_mount_glass_glass']
-                cec_modules = bz2.BZ2File(self.emhass_conf['root_path'] / 'data/cec_modules.pbz2', "rb")
+                cec_modules = bz2.BZ2File(self.emhass_conf['root_path'] / 'data' / 'cec_modules.pbz2', "rb")
                 cec_modules = cPickle.load(cec_modules)
-                cec_inverters = bz2.BZ2File(self.emhass_conf['root_path'] / 'data/cec_inverters.pbz2', "rb")
+                cec_inverters = bz2.BZ2File(self.emhass_conf['root_path'] / 'data' /  'cec_inverters.pbz2', "rb")
                 cec_inverters = cPickle.load(cec_inverters)
                 if type(self.plant_conf['module_model']) == list:
                     P_PV_forecast = pd.Series(0, index=df_weather.index)
@@ -838,5 +896,4 @@ class Forecast(object):
         else:
             self.logger.error("Passed method is not valid")
             return False
-        return df_final
-    
+        return df_final

emhass/machine_learning_forecaster.py

@@ -221,51 +221,52 @@ class MLForecaster:
         :return: The DataFrame with the forecasts using the optimized model.
         :rtype: pd.DataFrame
         """
-        # Bayesian search hyperparameter and lags with skforecast/optuna
-        # Lags used as predictors
-        if debug:
-            lags_grid = [3]
-            refit = False
-            num_lags = 3
-        else:
-            lags_grid = [6, 12, 24, 36, 48, 60, 72]
-            refit = True
-            num_lags = self.num_lags
         # Regressor hyperparameters search space
         if self.sklearn_model == 'LinearRegression':
             if debug:
                 def search_space(trial):
-                    search_space  = {'fit_intercept': trial.suggest_categorical('fit_intercept', [True])} 
+                    search_space  = {'fit_intercept': trial.suggest_categorical('fit_intercept', [True]),
+                                     'lags': trial.suggest_categorical('lags', [3])} 
                     return search_space
             else:
                 def search_space(trial):
-                    search_space  = {'fit_intercept': trial.suggest_categorical('fit_intercept', [True, False])} 
+                    search_space  = {'fit_intercept': trial.suggest_categorical('fit_intercept', [True, False]),
+                                     'lags': trial.suggest_categorical('lags', [6, 12, 24, 36, 48, 60, 72])}
                     return search_space
         elif self.sklearn_model == 'ElasticNet':
             if debug:
                 def search_space(trial):
-                    search_space  = {'selection': trial.suggest_categorical('selection', ['random'])} 
+                    search_space  = {'selection': trial.suggest_categorical('selection', ['random']),
+                                     'lags': trial.suggest_categorical('lags', [3])} 
                     return search_space
             else:
                 def search_space(trial):
                     search_space  = {'alpha': trial.suggest_float('alpha', 0.0, 2.0),
                                     'l1_ratio': trial.suggest_float('l1_ratio', 0.0, 1.0),
-                                    'selection': trial.suggest_categorical('selection', ['cyclic', 'random'])
-                                    } 
+                                    'selection': trial.suggest_categorical('selection', ['cyclic', 'random']),
+                                    'lags': trial.suggest_categorical('lags', [6, 12, 24, 36, 48, 60, 72])} 
                     return search_space
         elif self.sklearn_model == 'KNeighborsRegressor':
             if debug:
                 def search_space(trial):
-                    search_space  = {'weights': trial.suggest_categorical('weights', ['uniform'])} 
+                    search_space  = {'weights': trial.suggest_categorical('weights', ['uniform']),
+                                     'lags': trial.suggest_categorical('lags', [3])} 
                     return search_space
             else:
                 def search_space(trial):
                     search_space  = {'n_neighbors': trial.suggest_int('n_neighbors', 2, 20),
                                     'leaf_size': trial.suggest_int('leaf_size', 20, 40),
-                                    'weights': trial.suggest_categorical('weights', ['uniform', 'distance'])
-                                    } 
+                                    'weights': trial.suggest_categorical('weights', ['uniform', 'distance']),
+                                    'lags': trial.suggest_categorical('lags', [6, 12, 24, 36, 48, 60, 72])} 
                     return search_space
-        
+        # Bayesian search hyperparameter and lags with skforecast/optuna
+        # Lags used as predictors
+        if debug:
+            refit = False
+            num_lags = 3
+        else:
+            refit = True
+            num_lags = self.num_lags
         # The optimization routine call
         self.logger.info("Bayesian hyperparameter optimization with backtesting")
         start_time = time.time()
@@ -273,7 +274,6 @@ class MLForecaster:
             forecaster         = self.forecaster,
             y                  = self.data_train[self.var_model],
             exog               = self.data_train.drop(self.var_model, axis=1),
-            lags_grid          = lags_grid,
             search_space       = search_space,
             steps              = num_lags,
             metric             = MLForecaster.neg_r2_score,

emhass/optimization.py

@@ -272,12 +272,20 @@ class Optimization:
                     rhs = 0)
                 for i in set_I}
         else:
-            constraints = {"constraint_main1_{}".format(i) :
-                plp.LpConstraint(
-                    e = P_PV[i] - P_PV_curtailment[i] - P_def_sum[i] - P_load[i] + P_grid_neg[i] + P_grid_pos[i] + P_sto_pos[i] + P_sto_neg[i],
-                    sense = plp.LpConstraintEQ,
-                    rhs = 0)
-                for i in set_I}
+            if self.plant_conf['compute_curtailment']:
+                constraints = {"constraint_main2_{}".format(i) :
+                    plp.LpConstraint(
+                        e = P_PV[i] - P_PV_curtailment[i] - P_def_sum[i] - P_load[i] + P_grid_neg[i] + P_grid_pos[i] + P_sto_pos[i] + P_sto_neg[i],
+                        sense = plp.LpConstraintEQ,
+                        rhs = 0)
+                    for i in set_I}
+            else:
+                constraints = {"constraint_main3_{}".format(i) :
+                    plp.LpConstraint(
+                        e = P_PV[i] - P_def_sum[i] - P_load[i] + P_grid_neg[i] + P_grid_pos[i] + P_sto_pos[i] + P_sto_neg[i],
+                        sense = plp.LpConstraintEQ,
+                        rhs = 0)
+                    for i in set_I}
         
         # Constraint for hybrid inverter and curtailment cases
         if type(self.plant_conf['module_model']) == list:
@@ -312,12 +320,13 @@ class Optimization:
                     rhs = 0)
                 for i in set_I})
         else:
-            constraints.update({"constraint_curtailment_{}".format(i) :
-                plp.LpConstraint(
-                    e = P_PV[i] - P_PV_curtailment[i] - P_nom_inverter,
-                    sense = plp.LpConstraintLE,
-                    rhs = 0)
-                for i in set_I})
+            if self.plant_conf['compute_curtailment']:
+                constraints.update({"constraint_curtailment_{}".format(i) :
+                    plp.LpConstraint(
+                        e = P_PV_curtailment[i] - max(P_PV[i],0),
+                        sense = plp.LpConstraintLE,
+                        rhs = 0)
+                    for i in set_I})
             
         # Constraint for sequence of deferrable
         # WARNING: This is experimental, formulation seems correct but feasibility problems.
@@ -363,13 +372,13 @@ class Optimization:
         # Two special constraints just for a self-consumption cost function
         if self.costfun == 'self-consumption':
             if type_self_conso == 'maxmin': # maxmin linear problem
-                constraints.update({"constraint_selfcons_PV_{}".format(i) : 
+                constraints.update({"constraint_selfcons_PV1_{}".format(i) : 
                     plp.LpConstraint(
                         e = SC[i] - P_PV[i],
                         sense = plp.LpConstraintLE,
                         rhs = 0)
                     for i in set_I})
-                constraints.update({"constraint_selfcons_PV_{}".format(i) : 
+                constraints.update({"constraint_selfcons_PV2_{}".format(i) : 
                     plp.LpConstraint(
                         e = SC[i] - P_load[i] - P_def_sum[i],
                         sense = plp.LpConstraintLE,
@@ -439,41 +448,27 @@ class Optimization:
                             sense=plp.LpConstraintLE,
                             rhs=0)
                         for i in set_I})
-                # Treat the number of starts for a deferrable load
-                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 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
+                # 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
@@ -644,7 +639,8 @@ class Optimization:
             opt_tp["SOC_opt"] = SOC_opt
         if self.plant_conf['inverter_is_hybrid']:
             opt_tp["P_hybrid_inverter"] = [P_hybrid_inverter[i].varValue for i in set_I]
-        opt_tp["P_PV_curtailment"] = [P_PV_curtailment[i].varValue for i in set_I]
+        if self.plant_conf['compute_curtailment']:
+            opt_tp["P_PV_curtailment"] = [P_PV_curtailment[i].varValue for i in set_I]
         opt_tp.index = data_opt.index
 
         # Lets compute the optimal cost function

emhass/utils.py

@@ -11,6 +11,7 @@ import numpy as np
 import pandas as pd
 import yaml
 import pytz
+import ast
 
 import plotly.express as px
 
@@ -161,6 +162,16 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
             "unit_of_measurement": "W",
             "friendly_name": "Load Power Forecast",
         },
+        "custom_pv_curtailment_id": {
+            "entity_id": "sensor.p_pv_curtailment",
+            "unit_of_measurement": "W",
+            "friendly_name": "PV Power Curtailment",
+        },
+        "custom_hybrid_inverter_id": {
+            "entity_id": "sensor.p_hybrid_inverter",
+            "unit_of_measurement": "W",
+            "friendly_name": "PV Hybrid Inverter",
+        },
         "custom_batt_forecast_id": {
             "entity_id": "sensor.p_batt_forecast",
             "unit_of_measurement": "W",
@@ -242,7 +253,6 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
             if "target" in runtimeparams:
                 target = runtimeparams["target"]
                 params["passed_data"]["target"] = target
-
         # Treating special data passed for MPC control case
         if set_type == "naive-mpc-optim":
             if "prediction_horizon" not in runtimeparams.keys():
@@ -298,6 +308,18 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
         # 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']
+        # Param to save forecast cache (i.e. Solcast)
+        if "weather_forecast_cache" not in runtimeparams.keys():
+            weather_forecast_cache = False
+        else:
+            weather_forecast_cache = runtimeparams["weather_forecast_cache"]
+        params["passed_data"]["weather_forecast_cache"] = weather_forecast_cache  
+        # Param to make sure optimization only uses cached data. (else produce error)
+        if "weather_forecast_cache_only" not in runtimeparams.keys():
+            weather_forecast_cache_only = False
+        else:
+            weather_forecast_cache_only = runtimeparams["weather_forecast_cache_only"]
+        params["passed_data"]["weather_forecast_cache_only"] = weather_forecast_cache_only  
         for method, forecast_key in enumerate(list_forecast_key):
             if forecast_key in runtimeparams.keys():
                 if type(runtimeparams[forecast_key]) == list and len(runtimeparams[forecast_key]) >= len(forecast_dates):
@@ -352,14 +374,12 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
         if "perform_backtest" not in runtimeparams.keys():
             perform_backtest = False
         else:
-            perform_backtest = eval(str(runtimeparams["perform_backtest"]).capitalize())
+            perform_backtest = ast.literal_eval(str(runtimeparams["perform_backtest"]).capitalize())
         params["passed_data"]["perform_backtest"] = perform_backtest
         if "model_predict_publish" not in runtimeparams.keys():
             model_predict_publish = False
         else:
-            model_predict_publish = eval(
-                str(runtimeparams["model_predict_publish"]).capitalize()
-            )
+            model_predict_publish = ast.literal_eval(str(runtimeparams["model_predict_publish"]).capitalize())
         params["passed_data"]["model_predict_publish"] = model_predict_publish
         if "model_predict_entity_id" not in runtimeparams.keys():
             model_predict_entity_id = "sensor.p_load_forecast_custom_model"
@@ -416,12 +436,16 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
             optim_conf["def_current_state"] = [bool(s) for s in runtimeparams["def_current_state"]]
         if "treat_def_as_semi_cont" in runtimeparams.keys():
             optim_conf["treat_def_as_semi_cont"] = [
-                eval(str(k).capitalize())
+                ast.literal_eval(str(k).capitalize())
                 for k in runtimeparams["treat_def_as_semi_cont"]
             ]
         if "set_def_constant" in runtimeparams.keys():
             optim_conf["set_def_constant"] = [
-                eval(str(k).capitalize()) for k in runtimeparams["set_def_constant"]
+                ast.literal_eval(str(k).capitalize()) for k in runtimeparams["set_def_constant"]
+            ]
+        if "def_start_penalty" in runtimeparams.keys():
+            optim_conf["def_start_penalty"] = [
+                ast.literal_eval(str(k).capitalize()) for k in runtimeparams["def_start_penalty"]
             ]
         if "solcast_api_key" in runtimeparams.keys():
             retrieve_hass_conf["solcast_api_key"] = runtimeparams["solcast_api_key"]
@@ -447,8 +471,16 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
         if 'continual_publish' in runtimeparams.keys():
             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"]
+        if "SOCmax" in runtimeparams.keys():
+            plant_conf["SOCmax"] = runtimeparams["SOCmax"]
         if "SOCtarget" in runtimeparams.keys():
             plant_conf["SOCtarget"] = runtimeparams["SOCtarget"]
+        if "Pd_max" in runtimeparams.keys():
+            plant_conf["Pd_max"] = runtimeparams["Pd_max"]
+        if "Pc_max" in runtimeparams.keys():
+            plant_conf["Pc_max"] = runtimeparams["Pc_max"]
         # Treat custom entities id's and friendly names for variables
         if "custom_pv_forecast_id" in runtimeparams.keys():
             params["passed_data"]["custom_pv_forecast_id"] = runtimeparams[
@@ -458,6 +490,14 @@ def treat_runtimeparams(runtimeparams: str, params: str, retrieve_hass_conf: dic
             params["passed_data"]["custom_load_forecast_id"] = runtimeparams[
                 "custom_load_forecast_id"
             ]
+        if "custom_pv_curtailment_id" in runtimeparams.keys():
+            params["passed_data"]["custom_pv_curtailment_id"] = runtimeparams[
+                "custom_pv_curtailment_id"
+            ]
+        if "custom_hybrid_inverter_id" in runtimeparams.keys():
+            params["passed_data"]["custom_hybrid_inverter_id"] = runtimeparams[
+                "custom_hybrid_inverter_id"
+            ]
         if "custom_batt_forecast_id" in runtimeparams.keys():
             params["passed_data"]["custom_batt_forecast_id"] = runtimeparams[
                 "custom_batt_forecast_id"
@@ -745,9 +785,7 @@ def build_params(params: dict, params_secrets: dict, options: dict, addon: int,
         params["retrieve_hass_conf"]["var_load"] = options.get("sensor_power_load_no_var_loads", params["retrieve_hass_conf"]["var_load"])
         params["retrieve_hass_conf"]["load_negative"] = options.get("load_negative", params["retrieve_hass_conf"]["load_negative"])
         params["retrieve_hass_conf"]["set_zero_min"] = options.get("set_zero_min", params["retrieve_hass_conf"]["set_zero_min"])
-        params["retrieve_hass_conf"]["var_replace_zero"] = [
-            options.get("sensor_power_photovoltaics", params["retrieve_hass_conf"]["var_replace_zero"])
-        ]
+        params["retrieve_hass_conf"]["var_replace_zero"] = [options.get("sensor_power_photovoltaics", params["retrieve_hass_conf"]["var_replace_zero"])]
         params["retrieve_hass_conf"]["var_interp"] = [
             options.get("sensor_power_photovoltaics", params["retrieve_hass_conf"]["var_PV"]),
             options.get("sensor_power_load_no_var_loads", params["retrieve_hass_conf"]["var_load"])
@@ -764,20 +802,11 @@ def build_params(params: dict, params_secrets: dict, options: dict, addon: int,
         params["optim_conf"]["set_use_battery"] = options.get("set_use_battery", params["optim_conf"]["set_use_battery"])
         params["optim_conf"]["num_def_loads"] = options.get("number_of_deferrable_loads", params["optim_conf"]["num_def_loads"])
         if options.get("list_nominal_power_of_deferrable_loads", None) != None:
-            params["optim_conf"]["P_deferrable_nom"] = [
-                i["nominal_power_of_deferrable_loads"]
-                for i in options.get("list_nominal_power_of_deferrable_loads")
-            ]
+            params["optim_conf"]["P_deferrable_nom"] = [i["nominal_power_of_deferrable_loads"] for i in options.get("list_nominal_power_of_deferrable_loads")]
         if options.get("list_operating_hours_of_each_deferrable_load", None) != None:
-            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")
-            ]
+            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")
-            ]
+            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")]
         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":
@@ -789,19 +818,14 @@ def build_params(params: dict, params_secrets: dict, options: dict, addon: int,
         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")
-            ]
+            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"]
-            ]
+            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"]]
             num_peak_hours = len(start_hours_list)
             list_hp_periods_list = [{'period_hp_'+str(i+1):[{'start':start_hours_list[i]},{'end':end_hours_list[i]}]} for i in range(num_peak_hours)]
             params['optim_conf']['list_hp_periods'] = list_hp_periods_list
@@ -839,6 +863,7 @@ def build_params(params: dict, params_secrets: dict, options: dict, addon: int,
         if options.get('list_strings_per_inverter',None) != None: 
             params['plant_conf']['strings_per_inverter'] = [i['strings_per_inverter'] for i in options.get('list_strings_per_inverter')]
         params["plant_conf"]["inverter_is_hybrid"] = options.get("inverter_is_hybrid", params["plant_conf"]["inverter_is_hybrid"])
+        params["plant_conf"]["compute_curtailment"] = options.get("compute_curtailment", params["plant_conf"]["compute_curtailment"])
         params['plant_conf']['Pd_max'] = options.get('battery_discharge_power_max', params['plant_conf']['Pd_max']) 
         params['plant_conf']['Pc_max'] = options.get('battery_charge_power_max', params['plant_conf']['Pc_max'])
         params['plant_conf']['eta_disch'] = options.get('battery_discharge_efficiency', params['plant_conf']['eta_disch'])

emhass/web_server.py

@@ -12,7 +12,7 @@ from distutils.util import strtobool
 
 from emhass.command_line import set_input_data_dict
 from emhass.command_line import perfect_forecast_optim, dayahead_forecast_optim, naive_mpc_optim
-from emhass.command_line import forecast_model_fit, forecast_model_predict, forecast_model_tune
+from emhass.command_line import forecast_model_fit, forecast_model_predict, forecast_model_tune, weather_forecast_cache
 from emhass.command_line import regressor_model_fit, regressor_model_predict
 from emhass.command_line import publish_data, continual_publish
 from emhass.utils import get_injection_dict, get_injection_dict_forecast_model_fit, \
@@ -106,6 +106,17 @@ def action_call(action_name):
     if runtimeparams is not None and runtimeparams != '{}':
         app.logger.info("Passed runtime parameters: " + str(runtimeparams))
     runtimeparams = json.dumps(runtimeparams)
+    
+    # Run action if weather_forecast_cache
+    if action_name == 'weather-forecast-cache':
+        ActionStr = " >> Performing weather forecast, try to caching result"
+        app.logger.info(ActionStr)
+        weather_forecast_cache(emhass_conf, params, runtimeparams, app.logger)
+        msg = f'EMHASS >> Weather Forecast has run and results possibly cached... \n'
+        if not checkFileLog(ActionStr):
+            return make_response(msg, 201)
+        return make_response(grabLog(ActionStr), 400)
+
     ActionStr = " >> Setting input data dict"
     app.logger.info(ActionStr)
     input_data_dict = set_input_data_dict(emhass_conf, costfun, 
@@ -459,15 +470,14 @@ if __name__ == "__main__":
     app.logger.addHandler(fileLogger)   
     clearFileLog() #Clear Action File logger file, ready for new instance
 
-
-    #If entity_path exists, remove any entity/metadata files 
+    # If entity_path exists, remove any entity/metadata files 
     entity_path = emhass_conf['data_path'] / "entities"
     if os.path.exists(entity_path): 
         entity_pathContents = os.listdir(entity_path)
         if len(entity_pathContents) > 0:
             for entity in entity_pathContents:
                 os.remove(entity_path / entity)
-
+        
     # Initialise continual publish thread list
     continual_publish_thread = []
     

{emhass-0.10.0.dist-info → emhass-0.10.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: emhass
-Version: 0.10.0
+Version: 0.10.2
 Summary: An Energy Management System for Home Assistant
 Home-page: https://github.com/davidusb-geek/emhass
 Author: David HERNANDEZ
@@ -28,7 +28,7 @@ Requires-Dist: h5py ==3.11.0
 Requires-Dist: pulp >=2.4
 Requires-Dist: pyyaml >=5.4.1
 Requires-Dist: tables <=3.9.1
-Requires-Dist: skforecast ==0.12.0
+Requires-Dist: skforecast ==0.12.1
 Requires-Dist: flask >=2.0.3
 Requires-Dist: waitress >=2.1.1
 Requires-Dist: plotly >=5.6.0
@@ -179,13 +179,9 @@ docker run -it --restart always -p 5000:5000  -e TZ="Europe/Paris"  -e LOCAL_COS
 ### Method 3) Legacy method using a Python virtual environment
 
 With this method it is recommended to install on a virtual environment.
-For this you will need `virtualenv`, install it using:
+Create and activate a virtual environment:
 ```bash
-sudo apt install python3-virtualenv
-```
-Then create and activate the virtual environment:
-```bash
-virtualenv -p /usr/bin/python3 emhassenv
+python3 -m venv emhassenv
 cd emhassenv
 source bin/activate
 ```
@@ -496,7 +492,7 @@ curl -i -H 'Content-Type:application/json' -X POST -d '{"publish_prefix":"all"}'
 ```
 This action will publish the dayahead (_dh) and MPC (_mpc) optimization results from the optimizations above.
 
-### Forecast data
+### Forecast data at runtime
 
 It is possible to provide EMHASS with your own forecast data. For this just add the data as list of values to a data dictionary during the call to `emhass` using the `runtimeparams` option. 
 
@@ -519,7 +515,7 @@ The possible dictionary keys to pass data are:
 
 - `prod_price_forecast` for the PV production selling price forecast.
 
-### Passing other data
+### Passing other data at runtime
 
 It is possible to also pass other data during runtime in order to automate the energy management. For example, it could be useful to dynamically update the total number of hours for each deferrable load (`def_total_hours`) using for instance a correlation with the outdoor temperature (useful for water heater for example). 
 
@@ -535,6 +531,8 @@ Here is the list of the other additional dictionary keys that can be passed at r
 
 - `def_end_timestep` for the timestep before which each deferrable load should operate (if you don't want the deferrable load to use the whole optimization timewindow).
 
+- `def_current_state` Pass this as a list of booleans (True/False) to indicate the current deferrable load state. This is used internally to avoid incorrectly penalizing a deferrable load start if a forecast is run when that load is already running.
+
 - `treat_def_as_semi_cont` to define if we should treat each deferrable load as a semi-continuous variable.
 
 - `set_def_constant` to define if we should set each deferrable load as a constant fixed value variable with just one startup for each optimization task.
@@ -545,8 +543,16 @@ Here is the list of the other additional dictionary keys that can be passed at r
 
 - `solar_forecast_kwp` for the PV peak installed power in kW used for the solar.forecast API call. 
 
+- `SOCmin` the minimum possible SOC.
+
+- `SOCmax` the maximum possible SOC.
+
 - `SOCtarget` for the desired target value of initial and final SOC.
 
+- `Pd_max` for the maximum battery discharge power.
+
+- `Pc_max` for the maximum battery charge power.
+
 - `publish_prefix` use this key to pass a common prefix to all published data. This will add a prefix to the sensor name but also to the forecasts attributes keys within the sensor.
 
 ## A naive Model Predictive Controller

{emhass-0.10.0.dist-info → emhass-0.10.2.dist-info}/RECORD

@@ -1,12 +1,12 @@
 emhass/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-emhass/command_line.py,sha256=RPMFS86McukgzoGmeq-DEMwyCZrpFx6Ko27Ndj_A0Fc,57211
-emhass/forecast.py,sha256=VdB8O6V4LYXdfIg7fHNRIVdvj2Y8Ow8Z7r1Ck3hvvh8,47631
-emhass/machine_learning_forecaster.py,sha256=az8cYRCckmR-WEdXyigbe8udtbj82yfahPmow4gue4s,15655
+emhass/command_line.py,sha256=jQib__atH07dEaTQuqTyvUk9irlVelvnipoc5Sw8CEg,60404
+emhass/forecast.py,sha256=ZwTjZxodszGM_1VBfFz5zhlzx0gobCQAkHA3PLjTXnA,53141
+emhass/machine_learning_forecaster.py,sha256=kUa5b5Ay3ZO7ceU7yUo1p5vu2DI6QbXMFmzX6IVLkzw,16027
 emhass/machine_learning_regressor.py,sha256=WmR9ODWkY64RAniqLowwf5tZWzPTVp5ftCTKNtzcd6I,10407
-emhass/optimization.py,sha256=bNn3txHurUNrnW-FFmY9MRokn1X1V50pjK9TNH3z-Es,47305
+emhass/optimization.py,sha256=LTIXc42IlMdARkstiqIHtDB0sryq230EohqJJsggKqE,47120
 emhass/retrieve_hass.py,sha256=k-BPZMqW-uQ95Q7Gzz93nPkLHStDCkI7-047GVYBGC0,22983
-emhass/utils.py,sha256=uc2yrcvA-GwJPsGOQIc_tEf3MxtGu_tMNf1PyyEx3Aw,48112
-emhass/web_server.py,sha256=8hzVjDTCSMdPwpgzstGiH11IArIYiaYGSYkAiMq4S78,24095
+emhass/utils.py,sha256=Q9X0pM3yMPVMoal6FVuUNft4RGZpLZYqeSWrwcg30AI,50380
+emhass/web_server.py,sha256=Kwx3YmNugxMDHHWMiK-cb8qjLmM9ugKvaj6HWnI_NYc,24638
 emhass/data/cec_inverters.pbz2,sha256=tK8FvAUDW0uYez8EPttdCJwHhpPofclYV6GhhNZL0Pk,168272
 emhass/data/cec_modules.pbz2,sha256=8vEaysgYffXg3KUl8XSF36Mdywzi3LpEtUN_qenjO9s,1655747
 emhass/static/advanced.html,sha256=15tYNw9ck_ds1zxQk0XXj7wmS9px_0x0GDx57cFx3vA,1970
@@ -18,9 +18,9 @@ emhass/static/img/emhass_logo_short.svg,sha256=yzMcqtBRCV8rH84-MwnigZh45_f9Eoqwh
 emhass/static/img/feather-sprite.svg,sha256=VHjMJQg88wXa9CaeYrKGhNtyK0xdd47zCqwSIa-hxo8,60319
 emhass/templates/index.html,sha256=_BsvUJ981uSQkx5H9tq_3es__x4WdPiOy7FjNoNYU9w,2744
 emhass/templates/template.html,sha256=TkGgMecQEbFUZA4ymPwMUzNjKHsENvCgroUWbPt7G4Y,158
-emhass-0.10.0.dist-info/LICENSE,sha256=1X3-S1yvOCBDBeox1aK3dq00m7dA8NDtcPrpKPISzbE,1077
-emhass-0.10.0.dist-info/METADATA,sha256=602w53NAKX6TNa7sQcTVpyZlUrlgcJn1yxX2oz9Hn_M,44352
-emhass-0.10.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-emhass-0.10.0.dist-info/entry_points.txt,sha256=6Bp1NFOGNv_fSTxYl1ke3K3h3aqAcBxI-bgq5yq-i1M,52
-emhass-0.10.0.dist-info/top_level.txt,sha256=L7fIX4awfmxQbAePtSdVg2e6x_HhghfReHfsKSpKr9I,7
-emhass-0.10.0.dist-info/RECORD,,
+emhass-0.10.2.dist-info/LICENSE,sha256=1X3-S1yvOCBDBeox1aK3dq00m7dA8NDtcPrpKPISzbE,1077
+emhass-0.10.2.dist-info/METADATA,sha256=4hytYJ1JCekiyvvaYSILPuE55e46ao9Iaf4KGFCB6XM,44679
+emhass-0.10.2.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+emhass-0.10.2.dist-info/entry_points.txt,sha256=6Bp1NFOGNv_fSTxYl1ke3K3h3aqAcBxI-bgq5yq-i1M,52
+emhass-0.10.2.dist-info/top_level.txt,sha256=L7fIX4awfmxQbAePtSdVg2e6x_HhghfReHfsKSpKr9I,7
+emhass-0.10.2.dist-info/RECORD,,

{emhass-0.10.0.dist-info → emhass-0.10.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (70.2.0)
 Root-Is-Purelib: true
 Tag: py3-none-any