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

emhass/optimization.py

@@ -3,6 +3,9 @@
 
 import logging
 import copy
+import pathlib
+import bz2
+import pickle as cPickle
 from typing import Optional, Tuple
 import pandas as pd
 import numpy as np
@@ -89,7 +92,7 @@ class Optimization:
         if self.lp_solver == 'COIN_CMD' and self.lp_solver_path == 'empty': #if COIN_CMD but lp_solver_path is empty
             self.logger.warning("lp_solver=COIN_CMD but lp_solver_path=empty, attempting to use lp_solver_path=/usr/bin/cbc")
             self.lp_solver_path = '/usr/bin/cbc'  
-        
+
     def perform_optimization(self, data_opt: pd.DataFrame, P_PV: np.array, P_load: np.array, 
                              unit_load_cost: np.array, unit_prod_price: np.array,
                              soc_init: Optional[float] = None, soc_final: Optional[float] = None,
@@ -153,14 +156,14 @@ class Optimization:
         if def_end_timestep is None:
             def_end_timestep = self.optim_conf['def_end_timestep']
         type_self_conso = 'bigm' # maxmin
-        
+
         #### The LP problem using Pulp ####
         opt_model = plp.LpProblem("LP_Model", plp.LpMaximize)
-        
+
         n = len(data_opt.index)
         set_I = range(n)
         M = 10e10
-        
+
         ## Add decision variables
         P_grid_neg  = {(i):plp.LpVariable(cat='Continuous',
                                           lowBound=-self.plant_conf['P_to_grid_max'], upBound=0,
@@ -171,12 +174,16 @@ class Optimization:
         P_deferrable = []
         P_def_bin1 = []
         for k in range(self.optim_conf['num_def_loads']):
+            if type(self.optim_conf['P_deferrable_nom'][k]) == list:
+                upBound = np.max(self.optim_conf['P_deferrable_nom'][k])
+            else:
+                upBound = self.optim_conf['P_deferrable_nom'][k]
             if self.optim_conf['treat_def_as_semi_cont'][k]:
                 P_deferrable.append({(i):plp.LpVariable(cat='Continuous',
                                                         name="P_deferrable{}_{}".format(k, i)) for i in set_I})
             else:
                 P_deferrable.append({(i):plp.LpVariable(cat='Continuous',
-                                                        lowBound=0, upBound=self.optim_conf['P_deferrable_nom'][k],
+                                                        lowBound=0, upBound=upBound,
                                                         name="P_deferrable{}_{}".format(k, i)) for i in set_I})
             P_def_bin1.append({(i):plp.LpVariable(cat='Binary',
                                                   name="P_def{}_bin1_{}".format(k, i)) for i in set_I})
@@ -201,11 +208,16 @@ class Optimization:
         else:
             P_sto_pos  = {(i):i*0 for i in set_I}
             P_sto_neg  = {(i):i*0 for i in set_I}
-            
+
         if self.costfun == 'self-consumption':
             SC  = {(i):plp.LpVariable(cat='Continuous',
                                       name="SC_{}".format(i)) for i in set_I}
-            
+        if self.plant_conf['inverter_is_hybrid']:
+            P_hybrid_inverter = {(i):plp.LpVariable(cat='Continuous',
+                                                    name="P_hybrid_inverter{}".format(i)) for i in set_I}
+        P_PV_curtailment = {(i):plp.LpVariable(cat='Continuous', lowBound=0,
+                                               name="P_PV_curtailment{}".format(i)) for i in set_I}
+        
         ## Define objective
         P_def_sum= []
         for i in set_I:
@@ -238,17 +250,116 @@ class Optimization:
             objective = objective + plp.lpSum(-0.001*self.timeStep*(
                 self.optim_conf['weight_battery_discharge']*P_sto_pos[i] + \
                     self.optim_conf['weight_battery_charge']*P_sto_neg[i]) for i in set_I)
+
+        # Add term penalizing each startup where configured
+        if ("def_start_penalty" in self.optim_conf and self.optim_conf["def_start_penalty"]):
+            for k in range(self.optim_conf["num_def_loads"]):
+                if (len(self.optim_conf["def_start_penalty"]) > k and self.optim_conf["def_start_penalty"][k]):
+                    objective = objective + plp.lpSum(
+                        -0.001 * self.timeStep * self.optim_conf["def_start_penalty"][k] * P_def_start[k][i] *\
+                            unit_load_cost[i] * self.optim_conf['P_deferrable_nom'][k]
+                        for i in set_I)
+
         opt_model.setObjective(objective)
-        
+
         ## Setting constraints
         # The main constraint: power balance
-        constraints = {"constraint_main1_{}".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}
+        if self.plant_conf['inverter_is_hybrid']:
+            constraints = {"constraint_main1_{}".format(i) :
+                plp.LpConstraint(
+                    e = P_hybrid_inverter[i] - P_def_sum[i] - P_load[i] + P_grid_neg[i] + P_grid_pos[i] ,
+                    sense = plp.LpConstraintEQ,
+                    rhs = 0)
+                for i in set_I}
+        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}
+        
+        # Constraint for hybrid inverter and curtailment cases
+        if type(self.plant_conf['module_model']) == list:
+            P_nom_inverter = 0.0
+            for i in range(len(self.plant_conf['inverter_model'])):
+                if type(self.plant_conf['inverter_model'][i]) == str:
+                    cec_inverters = bz2.BZ2File(pathlib.Path(__file__).parent / 'data/cec_inverters.pbz2', "rb")
+                    cec_inverters = cPickle.load(cec_inverters)
+                    inverter = cec_inverters[self.plant_conf['inverter_model'][i]]
+                    P_nom_inverter += inverter.Paco
+                else:
+                    P_nom_inverter += self.plant_conf['inverter_model'][i]
+        else:
+            if type(self.plant_conf['inverter_model'][i]) == str:
+                cec_inverters = bz2.BZ2File(pathlib.Path(__file__).parent / 'data/cec_inverters.pbz2', "rb")
+                cec_inverters = cPickle.load(cec_inverters)
+                inverter = cec_inverters[self.plant_conf['inverter_model']]
+                P_nom_inverter = inverter.Paco
+            else:
+                P_nom_inverter = self.plant_conf['inverter_model']
+        if self.plant_conf['inverter_is_hybrid']:
+            constraints.update({"constraint_hybrid_inverter1_{}".format(i) :
+                plp.LpConstraint(
+                    e = P_PV[i] - P_PV_curtailment[i] + P_sto_pos[i] + P_sto_neg[i] - P_nom_inverter,
+                    sense = plp.LpConstraintLE,
+                    rhs = 0)
+                for i in set_I})
+            constraints.update({"constraint_hybrid_inverter2_{}".format(i) :
+                plp.LpConstraint(
+                    e = P_PV[i] - P_PV_curtailment[i] + P_sto_pos[i] + P_sto_neg[i] - P_hybrid_inverter[i],
+                    sense = plp.LpConstraintEQ,
+                    rhs = 0)
+                for i in set_I})
+        else:
+            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})
             
+        # 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':
             if type_self_conso == 'maxmin': # maxmin linear problem
@@ -264,7 +375,7 @@ class Optimization:
                         sense = plp.LpConstraintLE,
                         rhs = 0)
                     for i in set_I})
-        
+
         # Avoid injecting and consuming from grid at the same time
         constraints.update({"constraint_pgridpos_{}".format(i) : 
             plp.LpConstraint(
@@ -278,79 +389,145 @@ class Optimization:
                 sense = plp.LpConstraintLE,
                 rhs = 0)
             for i in set_I})
-            
+
         # Treat deferrable loads constraints
         for k in range(self.optim_conf['num_def_loads']):
-            # Total time of deferrable load
-            constraints.update({"constraint_defload{}_energy".format(k) :
-                plp.LpConstraint(
-                    e = plp.lpSum(P_deferrable[k][i]*self.timeStep for i in set_I),
-                    sense = plp.LpConstraintEQ,
-                    rhs = def_total_hours[k]*self.optim_conf['P_deferrable_nom'][k])
-                })
-            # 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) :
+            if type(self.optim_conf['P_deferrable_nom'][k]) == list:
+                continue
+            else:
+                # 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(0, def_start)),
+                        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])
                     })
-            if def_end > 0:                    
-                constraints.update({"constraint_defload{}_end_timestep".format(k) :
+                # Ensure deferrable loads consume energy between def_start_timestep & def_end_timestep
+                self.logger.debug("Deferrable load {}: Proposed optimization window: {} --> {}".format(
+                    k, def_start_timestep[k], def_end_timestep[k]))
+                def_start, def_end, warning = Optimization.validate_def_timewindow(
+                    def_start_timestep[k], def_end_timestep[k], ceil(def_total_hours[k]/self.timeStep), n)
+                if warning is not None: 
+                    self.logger.warning("Deferrable load {} : {}".format(k, warning))
+                self.logger.debug("Deferrable load {}: Validated optimization window: {} --> {}".format(
+                    k, def_start, def_end))
+                if def_start > 0:                    
+                    constraints.update({"constraint_defload{}_start_timestep".format(k) :
+                        plp.LpConstraint(
+                            e = plp.lpSum(P_deferrable[k][i]*self.timeStep for i in range(0, def_start)),
+                            sense = plp.LpConstraintEQ,
+                            rhs = 0)
+                        })
+                if def_end > 0:                    
+                    constraints.update({"constraint_defload{}_end_timestep".format(k) :
+                        plp.LpConstraint(
+                            e = plp.lpSum(P_deferrable[k][i]*self.timeStep for i in range(def_end, n)),
+                            sense = plp.LpConstraintEQ,
+                            rhs = 0)
+                        })
+                # 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
+                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_deferrable[k][i]*self.timeStep for i in range(def_end, n)),
+                        e = plp.lpSum(P_def_start[k][i] for i in set_I),
                         sense = plp.LpConstraintEQ,
-                        rhs = 0)
+                        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) :
+                # 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
+                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] - self.optim_conf['P_deferrable_nom'][k]*P_def_bin1[k][i],
+                        e=P_deferrable[k][i] - P_def_bin2[k][i] * M,
                         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) : 
+                # 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_deferrable[k][i] - P_def_bin2[k][i]*M,
+                        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 0),
+                        e=P_def_start[k][i]
+                        - P_def_bin2[k][i]
+                        + (P_def_bin2[k][i - 1] if i - 1 >= 0 else current_state),
                         sense=plp.LpConstraintGE,
                         rhs=0)
                     for i in set_I})
-                constraints.update({"constraint_pdef{}_start3".format(k) :
-                plp.LpConstraint(
-                    e = plp.lpSum(P_def_start[k][i] for i in set_I),
-                    sense = plp.LpConstraintEQ,
-                    rhs = 1)
-                })
-                constraints.update({"constraint_pdef{}_start4".format(k) :
-                plp.LpConstraint(
-                    e = plp.lpSum(P_def_bin2[k][i] for i in set_I),
-                    sense = plp.LpConstraintEQ,
-                    rhs = self.optim_conf['def_total_hours'][k]/self.timeStep)
-                })
-        
+                # 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})
+                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)
+                    })
+
         # The battery constraints
         if self.optim_conf['set_use_battery']:
             # Optional constraints to avoid charging the battery from the grid
@@ -423,7 +600,7 @@ class Optimization:
                     rhs=(soc_init - soc_final)*self.plant_conf['Enom']/self.timeStep)
                 })
         opt_model.constraints = constraints
-    
+
         ## Finally, we call the solver to solve our optimization model:
         # solving with default solver CBC
         if self.lp_solver == 'PULP_CBC_CMD':
@@ -435,7 +612,7 @@ class Optimization:
         else:
             self.logger.warning("Solver %s unknown, using default", self.lp_solver)
             opt_model.solve()
-        
+
         # The status of the solution is printed to the screen
         self.optim_status = plp.LpStatus[opt_model.status]
         self.logger.info("Status: " + self.optim_status)
@@ -444,7 +621,7 @@ class Optimization:
             return
         else:
             self.logger.info("Total value of the Cost function = %.02f", plp.value(opt_model.objective))
-            
+
         # Build results Dataframe
         opt_tp = pd.DataFrame()
         opt_tp["P_PV"] = [P_PV[i] for i in set_I]
@@ -465,8 +642,11 @@ class Optimization:
                 SOC_opt.append(SOCinit - SOC_opt_delta[i])
                 SOCinit = SOC_opt[i]
             opt_tp["SOC_opt"] = SOC_opt
+        if self.plant_conf['inverter_is_hybrid']:
+            opt_tp["P_hybrid_inverter"] = [P_hybrid_inverter[i].varValue for i in set_I]
+        opt_tp["P_PV_curtailment"] = [P_PV_curtailment[i].varValue for i in set_I]
         opt_tp.index = data_opt.index
-        
+
         # Lets compute the optimal cost function
         P_def_sum_tp = []
         for i in set_I:
@@ -479,7 +659,7 @@ class Optimization:
         else:
             opt_tp["cost_profit"] = [-0.001*self.timeStep*(unit_load_cost[i]*P_grid_pos[i].varValue + \
                 unit_prod_price[i]*P_grid_neg[i].varValue) for i in set_I]
-        
+
         if self.costfun == 'profit':
             if self.optim_conf['set_total_pv_sell']:
                 opt_tp["cost_fun_profit"] = [-0.001*self.timeStep*(unit_load_cost[i]*(P_load[i] + P_def_sum_tp[i]) + \
@@ -500,17 +680,16 @@ class Optimization:
                     unit_prod_price[i]*P_grid_neg[i].varValue) for i in set_I]
         else:
             self.logger.error("The cost function specified type is not valid")
-            
+
         # Add the optimization status
         opt_tp["optim_status"] = self.optim_status
-        
+
         # Debug variables
         if debug:
-            opt_tp["P_def_start_0"] = [P_def_start[0][i].varValue for i in set_I]
-            opt_tp["P_def_start_1"] = [P_def_start[1][i].varValue for i in set_I]
-            opt_tp["P_def_bin2_0"] = [P_def_bin2[0][i].varValue for i in set_I]
-            opt_tp["P_def_bin2_1"] = [P_def_bin2[1][i].varValue for i in set_I]
-        
+            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]
+
         return opt_tp
 
     def perform_perfect_forecast_optim(self, df_input_data: pd.DataFrame, days_list: pd.date_range) -> pd.DataFrame:
@@ -548,9 +727,9 @@ class Optimization:
                 self.opt_res = opt_tp
             else:
                 self.opt_res = pd.concat([self.opt_res, opt_tp], axis=0)
-        
+
         return self.opt_res
-        
+
     def perform_dayahead_forecast_optim(self, df_input_data: pd.DataFrame, 
                                         P_PV: pd.Series, P_load: pd.Series) -> pd.DataFrame:
         r"""
@@ -577,7 +756,7 @@ class Optimization:
                                                  P_load.values.ravel(), 
                                                  unit_load_cost, unit_prod_price)
         return self.opt_res
-        
+
     def perform_naive_mpc_optim(self, df_input_data: pd.DataFrame, P_PV: pd.Series, P_load: pd.Series,
                                 prediction_horizon: int, soc_init: Optional[float] = None, soc_final: Optional[float] = None,
                                 def_total_hours: Optional[list] = None,

emhass/retrieve_hass.py

@@ -3,6 +3,8 @@
 
 import json
 import copy
+import os
+import pathlib
 import datetime
 import logging
 from typing import Optional
@@ -61,7 +63,7 @@ class RetrieveHass:
         self.freq = freq
         self.time_zone = time_zone
         self.params = params
-        # self.emhass_conf = emhass_conf
+        self.emhass_conf = emhass_conf
         self.logger = logger
         self.get_data_from_file = get_data_from_file
 
@@ -304,9 +306,11 @@ class RetrieveHass:
         }
         return data
 
+
     def post_data(self, data_df: pd.DataFrame, idx: int, entity_id: str, unit_of_measurement: str,
                   friendly_name: str, type_var: str, from_mlforecaster: Optional[bool] = False,
-                  publish_prefix: Optional[str] = "") -> None:
+                  publish_prefix: Optional[str] = "", save_entities: Optional[bool] = False, 
+                  logger_levels: Optional[str] = "info", dont_post: Optional[bool] = False) -> None:
         r"""
         Post passed data to hass.
         
@@ -326,6 +330,12 @@ class RetrieveHass:
         :type type_var: str
         :param publish_prefix: A common prefix for all published data entity_id.
         :type publish_prefix: str, optional
+        :param save_entities: if entity data should be saved in data_path/entities
+        :type save_entities: bool, optional
+        :param logger_levels: set logger level, info or debug, to output  
+        :type logger_levels: str, optional
+        :param dont_post: dont post to HA
+        :type dont_post: bool, optional
 
         """
         # Add a possible prefix to the entity ID
@@ -340,10 +350,12 @@ class RetrieveHass:
         headers = {
             "Authorization": "Bearer " + self.long_lived_token,
             "content-type": "application/json",
-        }
+        }  
         # Preparing the data dict to be published
         if type_var == "cost_fun":
-            state = np.round(data_df.sum()[0], 2)
+            if isinstance(data_df.iloc[0],pd.Series): #if Series extract
+                data_df = data_df.iloc[:, 0]
+            state = np.round(data_df.sum(), 2)
         elif type_var == "unit_load_cost" or type_var == "unit_prod_price":
             state = np.round(data_df.loc[data_df.index[idx]], 4)
         elif type_var == "optim_status":
@@ -398,18 +410,54 @@ class RetrieveHass:
                 },
             }
         # Actually post the data
-        if self.get_data_from_file:
+        if self.get_data_from_file or dont_post:
             class response:
                 pass
             response.status_code = 200
             response.ok = True
         else:
             response = post(url, headers=headers, data=json.dumps(data))
+
         # Treating the response status and posting them on the logger
         if response.ok:
-            self.logger.info("Successfully posted to " + entity_id + " = " + str(state))
+
+            if logger_levels == "DEBUG":
+                self.logger.debug("Successfully posted to " + entity_id + " = " + str(state))
+            else:
+                self.logger.info("Successfully posted to " + entity_id + " = " + str(state))
+
+            # If save entities is set, save entity data to /data_path/entities
+            if (save_entities):
+                entities_path = self.emhass_conf['data_path'] / "entities"
+                
+                # Clarify folder exists
+                pathlib.Path(entities_path).mkdir(parents=True, exist_ok=True)
+                
+                # Save entity data to json file
+                result = data_df.to_json(index="timestamp", orient='index', date_unit='s', date_format='iso')
+                parsed = json.loads(result)
+                with open(entities_path / (entity_id + ".json"), "w") as file:                       
+                    json.dump(parsed, file, indent=4)
+                 
+                # Save the required metadata to json file
+                if os.path.isfile(entities_path / "metadata.json"):
+                    with open(entities_path / "metadata.json", "r") as file:
+                        metadata = json.load(file) 
+                else:
+                    metadata = {}
+                with open(entities_path / "metadata.json", "w") as file:                       
+                    # Save entity metadata, key = entity_id 
+                    metadata[entity_id] = {'name': data_df.name, 'unit_of_measurement': unit_of_measurement,'friendly_name': friendly_name,'type_var': type_var, 'freq': int(self.freq.seconds / 60)}
+                    
+                    # Find lowest frequency to set for continual loop freq
+                    if metadata.get("lowest_freq",None) == None or metadata["lowest_freq"] > int(self.freq.seconds / 60):
+                        metadata["lowest_freq"] = int(self.freq.seconds / 60)
+                    json.dump(metadata,file, indent=4)
+
+                    self.logger.debug("Saved " + entity_id + " to json file")   
+ 
         else:
-            self.logger.info(
+            self.logger.warning(
                 "The status code for received curl command response is: "
                 + str(response.status_code)
             )