def baseline_prices(day, Horizon_T, H, h, Mn, b, P_max, P_min, d):
n = d.shape[0] # number of nodes
"""
Find lambdas for the day (they will be deemed exogenous)
"""
lambdas = np.zeros((n, Horizon_T))
gammas = np.zeros(Horizon_T)
for j in range(Horizon_T):
"""
Here is a new optimization framework which is rigoursely the same as devised in the algorithm,
WARNING this is just for time period j.
We input the c and q, the price and quantity offered by the battery. Here 0,0 because we want the LMPs
without the battery
"""
c = 0
q = 0
model = economic_dispatch.run_ED_1period(d[:, j], b[:, j], P_max[:, j], P_min[:, j], c, q, H, h, Mn)
for k in range(n):
lambdas[k, j] = model.dual[model.injection_definition[k]] # here we store the dual variables of the injection definition constraint
gammas[j] = model.dual[model.injection_balance]
return lambdas, gammas
def baseline_prices():
Horizon_T, day = 48, 2
H, h, Mn, b, P_max, P_min, d = get_basics(Horizon_T, day)
n = d.shape[0] # number of nodes
"""
Find lambdas for the day (they will be deemed exogenous)
"""
lambdas = np.zeros((n, Horizon_T))
gammas = np.zeros(Horizon_T)
for j in range(Horizon_T):
"""
Here is a new optimization framework which is rigoursely the same as devised in the algorithm,
WARNING this is just for time period j.
We input the c and q, the price and quantity offered by the battery. Here 0,0 because we want the LMPs
without the battery
"""
c = 0
q = 0
model = economic_dispatch.run_ED_1period(d[:, j], b[:, j], P_max[:, j], P_min[:, j], c, q, H, h, Mn)
for k in range(n):
lambdas[k, j] = model.dual[model.injection_definition[k]] # here we store the dual variables of the injection definition constraint
gammas[j] = model.dual[model.injection_balance]
import matplotlib.pyplot as plt
fig, axs = plt.subplots(2, sharex=True, figsize=(15, 10), dpi=80, facecolor='w', edgecolor='k')
plt.subplots_adjust(hspace=.0)
fs = 20
# if Node is not None:
# Node_name = Nodes[Node]
# Nodes = [None] * len(Nodes)
# Nodes[Node] = Node_name
# Y = np.array(LMP_df[[f'{i}' for i in range(t)]][1:]).T - np.array([gamma_df.gamma[:t].tolist()]).T
# else:
# Y = np.array(LMP_df[[f'{i}' for i in range(t)]][1:]).T - np.array([gamma_df.gamma[:t].tolist()]).T
axs[0].plot(gammas)
axs[0].set_ylabel('Average price $\gamma$ [\$/MW]', fontsize=fs)
axs[0].set_ylim(bottom=0)
axs[0].set_title('Average price and congestion curves\n Baseline model, Sept. 2nd, 2019', fontsize=fs)
axs[0].grid()
for i in range(1, 20):
axs[1].plot(lambdas[i]-gammas, label=f'{i}')
# for i, y_arr, label in zip(range(1, 20), Y[1:, :], Nodes[1:].tolist()):
# if (label == 'MDN') | (label == 'HEN'):
# axs[1].plot(y_arr, label=f'{i} : {label}', linewidth=5)
# else:
# axs[1].plot(y_arr, label=f'{i} : {label}')
axs[1].legend()
axs[1].set_ylabel('$\lambda - \gamma$ [\$/MW]', fontsize=fs)
axs[1].set_xlabel('Time [h]', fontsize=fs)
plt.xticks(range(0, 48, 2), range(24))
axs[1].set_xlim([0, 48])
axs[1].grid()
plt.show()
def compute_table_score(lambdas, capacity_cost, *args, power_rate=2, list_of_nodes=None):
data = []
n = args[0].shape[0]
Horizon_T = args[0].shape[1]
d, b, P_max, P_min, H, h, Mn = args
list_of_nodes = list_of_nodes if list_of_nodes is not None else list(range(1, n))
for i_battery in list_of_nodes:
print("Price taker/maker program computed for Node ", i_battery)
model = price_making_algorithm.run_program(*args, i_battery=i_battery,
max_capacity=None, cost_of_battery=capacity_cost, power_rate=power_rate)
z_cap_store = pyo.value(model.z_cap)
benef = -pyo.value(model.obj) # model.obj = -lambda*u + B*z
arbitrage = -pyo.value(model.obj) + capacity_cost * z_cap_store
"""
test
"""
model_pt = price_taking_algorithm.run_program(lambdas, i_battery=i_battery, cost_of_battery=0,
max_capacity=z_cap_store,
power_rate=2)
df_pt = pd.DataFrame()
# df_pt["u"] = planning
planning = [pyo.value(model_pt.u[t]) for t in
range(Horizon_T)] # planning of push and pull from the network
expected_profits = sum([planning[i] * lambdas[10, i] for i in
range(Horizon_T)]) # expected profits (lambda cross u with lambdas as exogenous)
df_pt["u"] = planning
df_pt["e_profits"] = [planning[i] * lambdas[10, i] for i in
range(Horizon_T)]
df_pt["cumulated e profits"] = df_pt["e_profits"].cumsum()
n_lambdas = np.zeros((n, Horizon_T)) # new prices !
for j in range(Horizon_T):
"""
Here we sell and buy at 0 (i.e we self-schedule_) the quantity devised in the optimization algorithm
"""
model = economic_dispatch.run_ED_1period(d[:, j], b[:, j], P_max[:, j], P_min[:, j], 0, planning[j], H,
h, Mn,
i_battery=i_battery)
for k in range(d.shape[0]):
n_lambdas[k, j] = model.dual[model.injection_definition[k]]
actual_profits = sum([planning[i] * n_lambdas[i_battery, i] for i in range(Horizon_T)])
data.append([z_cap_store, benef, arbitrage, expected_profits, actual_profits])
df = pd.DataFrame(columns=["z_cap", "depreciated profits", "arbitrage only pm", "expected arbitrage pt",
"actual arbitrage pt"], data=data)
df["unit arbitrage pt"] = df["expected arbitrage pt"]/df["z_cap"]
df["node index"] = list_of_nodes
df = df.round(1)
df = df[["node index"] + list(df.columns)[:-1]]
return df.T
def plot_cum_prof(battery_index, lambdas, z_cap, *args):
# battery_index = 12
# z_cap = 45
d, b, P_max, P_min, H, h, Mn = args
n, Horizon_T = d.shape
model_baseline = price_making_algorithm.run_program(d, b, P_max, P_min, H, h, Mn, i_battery=battery_index,
max_capacity=0, cost_of_battery=0, power_rate=2)
lambda_baseline = [[pyo.value(model_baseline.lambda_[i, t]) for t in range(Horizon_T)] for i in range(d.shape[0])]
model_pm = price_making_algorithm.run_program(d, b, P_max, P_min, H, h, Mn, i_battery=battery_index,
max_capacity=z_cap, cost_of_battery=0, power_rate=2)
u = [pyo.value(model_pm.u[t]) for t in range(Horizon_T)] # or do that for array variable
lambda_ = [[pyo.value(model_pm.lambda_[i, t]) for t in range(Horizon_T)] for i in range(d.shape[0])]
df = pd.DataFrame(data=[u, lambda_[battery_index]]).T
df["benefits"] = df[0] * df[1]
df["cumulated profits"] = df["benefits"].cumsum()
df["z"] = [pyo.value(model_pm.z[t]) for t in range(Horizon_T)]
# test = pd.DataFrame(data=[lambdas[10], lambda_[10]])
model_pt = price_taking_algorithm.run_program(lambdas, i_battery=battery_index, cost_of_battery=0, max_capacity=z_cap,
power_rate=2)
df_pt = pd.DataFrame()
# df_pt["u"] = planning
planning = [pyo.value(model_pt.u[t]) for t in range(Horizon_T)] # planning of push and pull from the network
expected_profits = sum([planning[i] * lambdas[battery_index, i] for i in
range(Horizon_T)]) # expected profits (lambda cross u with lambdas as exogenous)
df_pt["u"] = planning
df_pt["e_profits"] = [planning[i] * lambdas[battery_index, i] for i in
range(Horizon_T)]
df_pt["cumulated e profits"] = df_pt["e_profits"].cumsum()
n_lambdas = np.zeros((n, Horizon_T)) # new prices !
for j in range(Horizon_T):
"""
Here we sell and buy at 0 (i.e we self-schedule_) the quantity devised in the optimization algorithm
"""
model = economic_dispatch.run_ED_1period(d[:, j], b[:, j], P_max[:, j], P_min[:, j], 0, planning[j], H, h, Mn,
i_battery=battery_index)
for k in range(n):
n_lambdas[k, j] = model.dual[model.injection_definition[k]]
# actual_profits = sum([planning[i] * n_lambdas[1, i] for i in range(Horizon_T)])
df_pt["a_profits"] = [planning[i] * n_lambdas[battery_index, i] for i in
range(Horizon_T)]
df_pt["cumulated a profits"] = df_pt["a_profits"].cumsum()
df_pt["z"] = [pyo.value(model_pt.z[t]) for t in range(Horizon_T)]
# plt.title("LMPs on node 10 taker vs maker")
# plt.plot(lambdas[10], label=r'$\lambda_{pm}$')
# plt.plot(n_lambdas[10], label=r'$\lambda_{pt}$')
# plt.legend(prop={'size': 17})
# plt.ylabel('\$')
# plt.xlabel("Time [trading periods]")
# plt.grid("True")
# plt.show()
lambda_gap_pt = n_lambdas[10] - lambda_baseline[10]
lambda_gap_pm = lambdas[10] - lambda_baseline[10]
fig, axs = plt.subplots(4, sharex=True, figsize=(12, 10), dpi=80, facecolor='w', edgecolor='k',
gridspec_kw={"height_ratios": [2, 1, 1, 1]})
plt.subplots_adjust(hspace=.0)
fs = 20
axs[0].plot(df["cumulated profits"], color="black", marker="x", label=r'Revenue PM')
axs[0].plot(df_pt["cumulated e profits"], color="green", marker="o", label="Expected revenue PT")
axs[0].plot(df_pt["cumulated a profits"], color="red", marker="*",
label="Actual revenue PM")
axs[0].set_ylabel('\$', fontsize=fs)
# axs[0].set_title('Cumulated profits, SOC, Maker vs Taker',
# fontsize=fs)
# axs[0].grid()
axs[0].legend(prop={'size': 17})
axs[1].bar(df_pt.index, df_pt["e_profits"] - df_pt["a_profits"], color="black", #marker="*",
label="Expected-Actual PT")
axs[1].set_ylabel('\$', fontsize=fs)
# axs[0].grid()
axs[1].legend(prop={'size': 17}, loc=2)
axs[2].bar(df_pt.index, lambda_gap_pt, color="darkred", # marker="*",
label=r"$\lambda_{PT} - \lambda_{BL}$")
axs[2].set_ylabel('\$', fontsize=fs)
# axs[0].grid()
axs[2].legend(prop={'size': 17}, loc=2)
axs[2].axhline(y=0, color="black", label=r"$\lambda_{PM} - \lambda_{BL}$")
axs[3].bar(df.index-0.15, df[0], width=0.15, label=r'$u$ PM') #SOC - price maker") #color="black", marker="x", linewidth=3, label="SOC - price maker"
axs[3].bar(df_pt.index+0.15, df_pt["u"], width=0.2, label=r'$u$ PT') #, color="green", marker="x", linestyle="dashed", label="SOC - price taker")
axs[3].axhline(y=0, color="black")
# for i, y_arr, label in zip(range(1, 20), Y[1:, :], Nodes[1:].tolist()):
# if (label == 'MDN') | (label == 'HEN'):
# axs[1].plot(y_arr, label=f'{i} : {label}', linewidth=5)
# else:
# axs[1].plot(y_arr, label=f'{i} : {label}')
axs[3].legend(prop={'size': 17}, loc=2)
axs[3].set_ylabel('MWh', fontsize=fs)
axs[3].set_xlabel('Time [h]', fontsize=fs)
plt.xticks(range(0, 48, 2), range(24))
axs[3].set_xlim([0, 48])
axs[0].axvspan(14, 17, alpha=0.1, color='black')
axs[0].axvspan(20, 23, alpha=0.1, color='black')
axs[0].axvspan(31, 41, alpha=0.1, color='black')
axs[1].axvspan(14, 17, alpha=0.1, color='black')
axs[1].axvspan(20, 23, alpha=0.1, color='black')
axs[1].axvspan(31, 41, alpha=0.1, color='black')
axs[2].axvspan(14, 17, alpha=0.1, color='black')
axs[2].axvspan(20, 23, alpha=0.1, color='black')
axs[2].axvspan(31, 41, alpha=0.1, color='black')
axs[3].axvspan(14, 17, alpha=0.1, color='black')
axs[3].axvspan(20, 23, alpha=0.1, color='black')
axs[3].axvspan(31, 41, alpha=0.1, color='black')
# axs[1].grid()
plt.show()
def plot_norm_2(*args, z_caps = np.linspace(1, 100, 11)):
d, b, P_max, P_min, H, h, Mn = args
n, Horizon_T = d.shape
lambdas = np.zeros((n, Horizon_T))
for j in range(Horizon_T):
"""
Here is a new optimization framework which is rigoursely the same as devised in the algorithm,
WARNING this is just for time period j.
We input the c and q, the price and quantity offered by the battery. Here 0,0 because we want the LMPs
without the battery
"""
c = 0
q = 0
model = economic_dispatch.run_ED_1period(d[:, j], b[:, j], P_max[:, j], P_min[:, j], c, q, H, h, Mn)
for k in range(n):
lambdas[k, j] = model.dual[model.injection_definition[
k]] # here we store the dual variables of the injection definition constraint
# g = np.array([pyo.value(model.g_t[i]) for i in range(b.shape[0])])
# cost_producer = np.inner(b[:,j], g)
lambda_base = lambdas[10]
lambdas_cap = []
# = [5, 10] + list(np.linspace(15, 200, 5))
for z_cap in z_caps:
print(z_cap)
i_Battery = 10
model = price_taking_algorithm.run_program(lambdas, i_battery=i_Battery, cost_of_battery=0, max_capacity=z_cap,
power_rate=2)
planning = [pyo.value(model.u[t]) for t in range(Horizon_T)] # planning of push and pull from the network
expected_profits = sum([planning[i] * lambdas[1, i] for i in
range(Horizon_T)]) # expected profits (lambda cross u with lambdas as exogenous)
n_lambdas = np.zeros((n, Horizon_T)) # new prices !
for j in range(Horizon_T):
"""
Here we sell and buy at 0 (i.e we self-schedule_) the quantity devised in the optimization algorithm
"""
model = economic_dispatch.run_ED_1period(d[:, j], b[:, j], P_max[:, j], P_min[:, j], 0, planning[j], H, h,
Mn,
i_battery=i_Battery)
for k in range(n):
n_lambdas[k, j] = model.dual[model.injection_definition[k]]
actual_profits = sum([planning[i] * n_lambdas[1, i] for i in range(Horizon_T)])
lambdas_pt = n_lambdas[i_Battery]
lambdas_cap.append(lambdas_pt)
lambdas_cap_pm = []
# z_caps_pm = np.linspace(1, 500, 10)
z_caps_pm = z_caps
for z_cap in z_caps_pm:
print(z_cap)
i_Battery = 10
model = price_making_algorithm.run_program(d, b, P_max, P_min, H, h, Mn, i_battery=i_Battery,
max_capacity=z_cap, cost_of_battery=0, power_rate=2)
lambda_ = [[pyo.value(model.lambda_[i, t]) for t in range(Horizon_T)] for i in range(d.shape[0])]
lambdas_pt = lambda_[i_Battery]
lambdas_cap_pm.append(lambdas_pt)
# z_caps = [z_caps[3]] + z_caps[:3] + z_caps[4:]
norm = []
norm_pm = []
for n_l in lambdas_cap:
norm.append(np.mean(abs(np.array(lambda_base - n_l))))
for n_l in lambdas_cap_pm:
norm_pm.append(np.mean(abs(np.array(lambda_base - n_l))))
# norm_pm.append(np.sqrt(sum(np.array(lambda_base - n_l) ** 2)))
# norm = [norm[3]] + norm[:3] + norm[4:]
plt.figure(figsize=(10, 6))
plt.plot(z_caps, norm, # linestyle="dashed",
label=r'pt : $|\lambda^{bl}_{10} - \lambda^{pt}_{10}|$')
plt.plot(z_caps_pm, norm_pm, label=r'pm : $|\lambda^{bl}_{10} - \lambda^{pm}_{10}|$')
# plt.title("Price taker vs maker strategy influence on LMP at node 10 in function of installed capacity")
plt.xlabel(r'$z_{cap}$', fontsize=17)
# plt.axhline(y=0, label="no difference in prices", color="black", linestyle="dotted")
# plt.ylabel("Norm 2 Difference between lmp without and with battery")
plt.legend(fontsize=17)
plt.show()
def how_to_deal_with_price_taker_algo(Horizon_T=48, day=2):
"""
You already know all this shit man
"""
H, h, Mn, b, P_max, P_min, d = get_basics(Horizon_T, day)
n = d.shape[0] #number of nodes
"""
Find lambdas for the day (they will be deemed exogenous)
"""
lambdas = np.zeros((n, Horizon_T))
for j in range(Horizon_T):
"""
Here is a new optimization framework which is rigoursely the same as devised in the algorithm,
WARNING this is just for time period j.
We input the c and q, the price and quantity offered by the battery. Here 0,0 because we want the LMPs
without the battery
"""
c = 0
q = 0
model = economic_dispatch.run_ED_1period(d[:, j], b[:, j], P_max[:, j],
P_min[:, j], c, q, H, h, Mn)
for k in range(n):
lambdas[k, j] = model.dual[model.injection_definition[
k]] #here we store the dual variables of the injection definition constraint
"""
Can you compare the lambdas of the economic dispatch with the one we find with the price maker dispatch ?
"""
"""
Price taking let's go !!
As for the maker, you choose the node of the battery, the cost (B), and the max_capacity (if none, will find the best)
"""
i_Battery = 1
objectives = []
cs = range(1, 200, 10)
for c in cs:
print(c)
model = price_taking_algorithm.run_program(lambdas,
i_battery=i_Battery,
cost_of_battery=c,
max_capacity=None)
objectives.append(pyo.value(model.z_cap))
import matplotlib.pyplot as plt
plt.plot(cs, objectives)
plt.show()
planning = [pyo.value(model.u[t]) for t in range(Horizon_T)
] #planning of push and pull from the network
expected_profits = sum([
planning[i] * lambdas[1, i] for i in range(Horizon_T)
]) #expected profits (lambda cross u with lambdas as exogenous)
n_lambdas = np.zeros((n, Horizon_T)) #new prices !
for j in range(Horizon_T):
"""
Here we sell and buy at 0 (i.e we self-schedule_) the quantity devised in the optimization algorithm
"""
model = economic_dispatch.run_ED_1period(d[:, j],
b[:, j],
P_max[:, j],
P_min[:, j],
0,
planning[j],
H,
h,
Mn,
i_battery=i_Battery)
for k in range(n):
n_lambdas[k, j] = model.dual[model.injection_definition[k]]
actual_profits = sum(
[planning[i] * n_lambdas[1, i] for i in range(Horizon_T)])
"""
def lambda_taker_price():
Horizon_T = 48
day = 2
H, h, Mn, b, P_max, P_min, d = get_basics(Horizon_T, day)
n = d.shape[0] # number of nodes
"""
Find lambdas for the day (they will be deemed exogenous)
"""
lambdas = np.zeros((n, Horizon_T))
for j in range(Horizon_T):
"""
Here is a new optimization framework which is rigoursely the same as devised in the algorithm,
WARNING this is just for time period j.
We input the c and q, the price and quantity offered by the battery. Here 0,0 because we want the LMPs
without the battery
"""
c = 0
q = 0
model = economic_dispatch.run_ED_1period(d[:, j], b[:, j], P_max[:, j],
P_min[:, j], c, q, H, h, Mn)
for k in range(n):
lambdas[k, j] = model.dual[model.injection_definition[
k]] # here we store the dual variables of the injection definition constraint
lambda_base = lambdas[10]
z_cap = 10
lambdas_cap = []
z_caps = [5, 10, 15] + list(np.linspace(1, 500, 25))
for z_cap in z_caps:
i_Battery = 10
model = price_taking_algorithm.run_program(lambdas,
i_battery=i_Battery,
cost_of_battery=0,
max_capacity=z_cap)
planning = [pyo.value(model.u[t]) for t in range(Horizon_T)
] # planning of push and pull from the network
expected_profits = sum([
planning[i] * lambdas[1, i] for i in range(Horizon_T)
]) # expected profits (lambda cross u with lambdas as exogenous)
n_lambdas = np.zeros((n, Horizon_T)) # new prices !
for j in range(Horizon_T):
"""
Here we sell and buy at 0 (i.e we self-schedule_) the quantity devised in the optimization algorithm
"""
model = economic_dispatch.run_ED_1period(d[:, j],
b[:, j],
P_max[:, j],
P_min[:, j],
0,
planning[j],
H,
h,
Mn,
i_battery=i_Battery)
for k in range(n):
n_lambdas[k, j] = model.dual[model.injection_definition[k]]
actual_profits = sum(
[planning[i] * n_lambdas[1, i] for i in range(Horizon_T)])
lambdas_pt = n_lambdas[i_Battery]
lambdas_cap.append(lambdas_pt)
lambdas_cap_pm = []
z_caps_pm = np.linspace(1, 500, 10)
for z_cap in z_caps_pm:
i_Battery = 10
model = price_making_algorithm.run_program(d,
b,
P_max,
P_min,
H,
h,
Mn,
i_battery=i_Battery,
max_capacity=z_cap,
cost_of_battery=0)
lambda_ = [[pyo.value(model.lambda_[i, t]) for t in range(Horizon_T)]
for i in range(d.shape[0])]
lambdas_pt = lambda_[i_Battery]
lambdas_cap_pm.append(lambdas_pt)
z_caps = [z_caps[3]] + z_caps[:3] + z_caps[4:]
norm = []
norm_pm = []
for n_l in lambdas_cap:
norm.append(np.sqrt(sum(np.array(lambda_base - n_l)**2)))
for n_l in lambdas_cap_pm:
norm_pm.append(np.sqrt(sum(np.array(lambda_base - n_l)**2)))
norm = [norm[3]] + norm[:3] + norm[4:]
import matplotlib.pyplot as plt
plt.figure(figsize=(10, 8))
plt.plot(
z_caps,
norm,
marker="x",
linestyle="dashed",
label=r'price taker : $||\lambda^{bl}_{10} - \lambda^{pt}_{10}||_2$')
plt.plot(
z_caps_pm,
norm_pm,
marker="o",
label=r'price maker : $||\lambda^{bl}_{10} - \lambda^{pm}_{10}||_2$')
plt.title("Price taker vs maker strategy influence on LMP at node 10")
plt.xlabel(r"z^{cap}")
plt.axhline(y=0,
label="no difference in prices",
color="black",
linestyle="dotted")
plt.ylabel("Norm 2 Difference between lmp without and with battery")
plt.legend()
plt.show()
def comparing_strategy():
Horizon_T, day = 48, 2
H, h, Mn, b, P_max, P_min, d = get_basics(Horizon_T, day)
n = d.shape[0] # number of nodes
y = 4.5 # amortize in 10 years
cost_of_battery = 200 * 1000 / (y * 365)
print("Launching model...")
model_pm = price_making_algorithm.run_program(d,
b,
P_max,
P_min,
H,
h,
Mn,
i_battery=10,
max_capacity=17,
cost_of_battery=0)
model_pm.z_cap.pprint()
u = [pyo.value(model_pm.u[t])
for t in range(Horizon_T)] # or do that for array variable
lambda_ = [[pyo.value(model_pm.lambda_[i, t]) for t in range(Horizon_T)]
for i in range(d.shape[0])]
df = pd.DataFrame(data=[u, lambda_[10]]).T
df["benefits"] = df[0] * df[1]
df["cumulated profits"] = df["benefits"].cumsum()
df["z"] = [pyo.value(model_pm.z[t]) for t in range(Horizon_T)]
# test = pd.DataFrame(data=[lambdas[10], lambda_[10]])
model_pt = price_taking_algorithm.run_program(lambdas,
i_battery=10,
cost_of_battery=0,
max_capacity=17)
df_pt = pd.DataFrame()
# df_pt["u"] = planning
planning = [pyo.value(model_pt.u[t]) for t in range(Horizon_T)
] # planning of push and pull from the network
expected_profits = sum([
planning[i] * lambdas[10, i] for i in range(Horizon_T)
]) # expected profits (lambda cross u with lambdas as exogenous)
df_pt["u"] = planning
df_pt["e_profits"] = [
planning[i] * lambdas[10, i] for i in range(Horizon_T)
]
df_pt["cumulated e profits"] = df_pt["e_profits"].cumsum()
n_lambdas = np.zeros((n, Horizon_T)) # new prices !
for j in range(Horizon_T):
"""
Here we sell and buy at 0 (i.e we self-schedule_) the quantity devised in the optimization algorithm
"""
model = economic_dispatch.run_ED_1period(d[:, j],
b[:, j],
P_max[:, j],
P_min[:, j],
0,
planning[j],
H,
h,
Mn,
i_battery=10)
for k in range(n):
n_lambdas[k, j] = model.dual[model.injection_definition[k]]
# actual_profits = sum([planning[i] * n_lambdas[1, i] for i in range(Horizon_T)])
df_pt["a_profits"] = [
planning[i] * n_lambdas[10, i] for i in range(Horizon_T)
]
df_pt["cumulated a profits"] = df_pt["a_profits"].cumsum()
df_pt["z"] = [pyo.value(model_pt.z[t]) for t in range(Horizon_T)]
plt.title("LMPs on node 10 taker vs maker")
plt.plot(lambdas[10], label=r'$\lambda_{pm}$')
plt.plot(n_lambdas[10], label=r'$\lambda_{pt}$')
plt.legend()
plt.ylabel('\$')
plt.xlabel("Time [trading periods]")
plt.grid("True")
plt.show()
fig, axs = plt.subplots(2,
sharex=True,
figsize=(12, 8),
dpi=80,
facecolor='w',
edgecolor='k')
plt.subplots_adjust(hspace=.0)
fs = 20
axs[0].plot(df["cumulated profits"],
color="black",
marker="x",
label="Cumulated profits - price maker")
axs[0].plot(df_pt["cumulated e profits"],
color="red",
marker="o",
label="Expected Cumulated profits - price taker")
axs[0].plot(df_pt["cumulated a profits"],
color="green",
marker="*",
label="Actuals Cumulated profits - price maker")
axs[0].set_ylabel('\$', fontsize=fs)
axs[0].set_ylim(bottom=0)
axs[0].set_title(
'Cumulated profits and Cleared volumes, Maker vs Taker \n Baseline model, Sept. 2nd, 2019',
fontsize=fs)
axs[0].grid()
axs[0].legend()
axs[1].plot(df["z"],
color="black",
marker="x",
linewidth=3,
label="SOC - price maker")
axs[1].plot(df_pt["z"],
color="green",
marker="x",
linestyle="dashed",
label="SOC - price taker")
# for i, y_arr, label in zip(range(1, 20), Y[1:, :], Nodes[1:].tolist()):
# if (label == 'MDN') | (label == 'HEN'):
# axs[1].plot(y_arr, label=f'{i} : {label}', linewidth=5)
# else:
# axs[1].plot(y_arr, label=f'{i} : {label}')
axs[1].legend()
axs[1].set_ylabel('MWh', fontsize=fs)
axs[1].set_xlabel('Time [h]', fontsize=fs)
plt.xticks(range(0, 48, 2), range(24))
axs[1].set_xlim([0, 48])
axs[1].grid()
plt.show()