P_grid = P_prod - P_sto
'''
P_prod = P_prod_data[k]
P_grid = P_prod - P_sto
P_grid_over = np.where(P_grid > 0.4, P_grid - 0.4, 0)
P_grid_neg = np.where(P_grid < 0, P_grid, 0)
penal = P_grid_over**2 + P_grid_neg**2 + 0 * P_sto**2
return penal
### Create the system description:
sto_sys = SysDescription((1, 1, 0),
name='Deterministic Storage for PV',
stationnary=False)
sto_sys.dyn = dyn_sto
sto_sys.control_box = admissible_controls
sto_sys.cost = cost_model
sto_sys.print_summary()
### Create the DP solver:
dpsolv = DPSolver(sto_sys)
# discretize the state space
N_E = 50
E_grid = dpsolv.discretize_state(0, E_rated, N_E)[0]
dpsolv.control_steps = (.001, )
dpsolv.print_summary()
J_fin = np.zeros(N_E)
'''penalty on the power injected to the grid
P_grid = P_prod - P_sto
penal = (P_grid/power_max)**2
'''
P_prod = searev_power(Speed)
P_grid = P_prod - P_sto
penal = (P_grid / power_max)**2
return penal
cost_label = 'quadratic cost'
### Create the system description:
searev_sys = SysDescription((3, 1, 1), name='Searev + Storage')
searev_sys.dyn = dyn_searev_sto
searev_sys.control_box = admissible_controls
searev_sys.cost = cost_model
searev_sys.perturb_laws = [innov_law]
#searev_sys.print_summary()
### Create the DP solver:
dpsolv = DPSolver(searev_sys)
# discretize the state space
N_E = 31
N_S = 61
N_A = 61
S_min, S_max = -4 * .254, 4 * 0.254
A_min, A_max = -4 * .227, 4 * .227
x_grid = dpsolv.discretize_state(0, E_rated, N_E, S_min, S_max, N_S, A_min,
A_max, N_A)
demand_law = demand_law.freeze()
demand_law.pmf([0, 3]) # Probality Mass Function
demand_law.rvs(10) # Random Variables generation
invsys.perturb_laws = [demand_law] # a list, to support several perturbations
def admissible_orders(x):
'interval of allowed orders U(x_k)'
U1 = (0, 10)
return (U1, ) # tuple, to support several controls
# Attach it to the system description.
invsys.control_box = admissible_orders
### Cost description g = r(x) + c.u
(h, p, c) = 0.5, 3, 1
def op_cost(x, u, w):
'operational cost of the shop'
holding = x * h
shortage = -x * p
order = u * c
return np.where(x > 0, holding, shortage) + order
# Test of the cost function
op_cost(1, 1, 0)
demand_law = demand_law.freeze()
demand_law.pmf([0, 3]) # Probality Mass Function
demand_law.rvs(10) # Random Variables generation
invsys.perturb_laws = [demand_law] # a list, to support several perturbations
def admissible_orders(x):
'interval of allowed orders U(x_k)'
U1 = (0, 10)
return (U1, ) # tuple, to support several controls
# Attach it to the system description.
invsys.control_box = admissible_orders
### Cost description g = r(x) + c.u
(h,p,c) = 0.5, 3, 1
def op_cost(x,u,w):
'operational cost of the shop'
holding = x*h
shortage = -x*p
order = u*c
return np.where(x>0, holding, shortage) + order
# Test of the cost function
op_cost(1,1,0)
# Vectorized cost computation capability (required):
op_cost(np.array([-2,-1,0,1,2]),1,0)
return (U1, )
def cost_model(k, E_sto, P_sto):
'''penalty on the power that is not absorbed
P_dev = P_req - P_sto
penal = P_dev**2
'''
P_req = p['P_req_data'][k]
P_dev = P_req - P_sto
penal = P_dev**2
return penal
### Create the system description:
sto_sys = SysDescription((1,1,0), name='Deterministic Storage', stationnary=False)
sto_sys.dyn = dyn_sto
sto_sys.control_box = admissible_controls
sto_sys.cost = cost_model
sto_sys.print_summary()
### Create the DP solver:
dpsolv = DPSolver(sto_sys)
# discretize the state space
N_E = 100
E_grid = dpsolv.discretize_state(0, p['E_rated'], N_E)[0]
dpsolv.control_steps=(.001,)
dpsolv.print_summary()
if __name__ == '__main__':
"""penalty on the power injected to the grid
P_grid = P_prod - P_sto
penal = (P_grid/power_max)**2
"""
P_prod = searev_power(Speed)
P_grid = P_prod - P_sto
penal = (P_grid / power_max) ** 2
return penal
cost_label = "quadratic cost"
### Create the system description:
searev_sys = SysDescription((3, 1, 1), name="Searev + Storage")
searev_sys.dyn = dyn_searev_sto
searev_sys.control_box = admissible_controls
searev_sys.cost = cost_model
searev_sys.perturb_laws = [innov_law]
# searev_sys.print_summary()
### Create the DP solver:
dpsolv = DPSolver(searev_sys)
# discretize the state space
N_E = 31
N_S = 61
N_A = 61
S_min, S_max = -4 * 0.254, 4 * 0.254
A_min, A_max = -4 * 0.227, 4 * 0.227
x_grid = dpsolv.discretize_state(0, E_rated, N_E, S_min, S_max, N_S, A_min, A_max, N_A)
E_grid, S_grid, A_grid = x_grid
