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_maker_algo(Horizon_T=10, day=2):
"""
Choose your number of trading period : Horizon T and your day. By default let's do everything
on day 2 and Horizon_T = 48
:param Horizon_T:
:param day:
:return:
"""
"""
The following line gets you the H,h, Mn (you already know)
b, P_max, P_min => the bids of each generator for the whole day (dimension g X horizonT)
d => demand of each node but we tweaked the case (look at tweak_d if you want to see how i do that)
Don't panic it takes a lot of time !!
"""
H, h, Mn, b, P_max, P_min, d = get_basics(Horizon_T, day)
"""
Below a first example how to run the price making algo :
some parameters are exogenous : d, b, P_max, P_min, H, h, Mn.
But :
@ always choose the location of the battery,
@ if you want to fix the maximum capacity fix it to something otherwise say "=None" and the algorithm will
find the best capacity
@cost of the battery the "B" of the article
In the example below best capacity for 0 cost of capacity at node 1
"""
model = price_making_algorithm.run_program(d,
b,
P_max,
P_min,
H,
h,
Mn,
i_battery=1,
max_capacity=10,
cost_of_battery=0)
model.z_cap.pprint(
) #To print the content of a variable or constraint do model.[name of variable].pprint()
# to see all the variables open the workspace and see all of the variables model contains
z_cap_store = pyo.value(model.z_cap) #use pyo.value to store
q_u_store = [pyo.value(model.q_u[t])
for t in range(Horizon_T)] #or do that for array variable
lambda_ = [[pyo.value(model.lambda_[i, t]) for t in range(Horizon_T)]
for i in range(d.shape[0])]
benef = -pyo.value(model.obj) #model.obj = -lambda*u + B*z
arbitrage = -pyo.value(
model.obj) + 55 * z_cap_store #-model.obj + Bz = lambda*u - B*z + B*z
gamma_ = np.array([pyo.value(model.gamma_[t]) for t in range(Horizon_T)])
plt.plot(lambda_[1] - gamma_)
plt.show()
"""
You can also save the results using save_results function (as we did last week)
"""
y = 4.5 # amortize in 10 years
cost_of_battery = 200 * 1000 / (y * 365)
print("Launching model...")
model = price_making_algorithm.run_program(d,
b,
P_max,
P_min,
H,
h,
Mn,
i_battery=10,
max_capacity=None,
cost_of_battery=cost_of_battery)
model.z_cap.pprint()
print("Model computed")
save_results(
model, d, Horizon_T, i_test=0
) #i-test is the number of the folder in which you store the results
data = []
for i in range(1, d.shape[0]):
model = price_making_algorithm.run_program(
d,
b,
P_max,
P_min,
H,
h,
Mn,
i_battery=i,
max_capacity=None,
cost_of_battery=cost_of_battery)
z_cap_store = pyo.value(model.z_cap) # use pyo.value to store
q_u_store = [pyo.value(model.q_u[t]) for t in range(Horizon_T)
] # or do that for array variable
lambda_ = [[pyo.value(model.lambda_[i, t]) for t in range(Horizon_T)]
for i in range(d.shape[0])]
benef = -pyo.value(model.obj) # model.obj = -lambda*u + B*z
arbitrage = -pyo.value(model.obj) + cost_of_battery * z_cap_store
data.append([benef, arbitrage, z_cap_store])
df = pd.DataFrame(
columns=["depreciated profits", "arbitrage only", "z_cap"], data=data)
df["node index"] = range(1, d.shape[0])
df = df[["node index", "depreciated profits", "arbitrage only", "z_cap"]]
print(df.round(3).to_latex())
"""
Let's get to it and store some nice output !!!!
Let's do it man !!
"""
"""
1st example : get the objective function value and zcap in function of the index of the nodes
WARNING : the profit of the battery is different from the objective function.
Obj function = profit - B*z_cap !
"""
benefits_per_node = []
zcap_per_node = []
for j in range(1, d.shape[0]):
print("Launching model for node {}...".format(j))
model = price_making_algorithm.run_program(
d,
b,
P_max,
P_min,
H,
h,
Mn,
i_battery=j,
max_capacity=None,
cost_of_battery=cost_of_battery)
print("Model computed")
print("\n___ OBJ ____")
print(pyo.value(model.obj))
benefits_per_node.append(
pyo.value(model.obj)
) #here we store the result of the constraint obj (not the variable)
zcap_per_node.append(pyo.value(model.z_cap))
print("\n")
"""
second example : get the objective function value and zcap of node 10 (the congested node remember)
in function of amortizement.
The longer you can wait to amortize your investment the more likely you will install a f*****g fat battery
"""
benefits_per_node = []
zcap_per_node = []
for y in list(range(1, 10)) + [1000]:
print("Launching model...")
cost_of_battery = 200 * 1000 / (y * 365)
model = price_making_algorithm.run_program(
d,
b,
P_max,
P_min,
H,
h,
Mn,
i_battery=10,
max_capacity=None,
cost_of_battery=cost_of_battery)
print("Model computed")
print("\n___ OBJ ____")
print(pyo.value(model.obj)) # get the benefits
benefits_per_node.append(pyo.value(model.obj))
zcap_per_node.append(pyo.value(model.z_cap))
print("\n")
"""
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()