def post_solve(instance, outdir):
"""
Export storage build information to storage_builds.txt, and storage
dispatch info to storage_dispatch.txt
"""
import switch_mod.export as export
export.write_table(
instance, instance.STORAGE_PROJECT_BUILDYEARS,
output_file=os.path.join(outdir, "storage_builds.txt"),
headings=("project", "period", "load_zone",
"IncrementalPowerCapacityMW", "IncrementalEnergyCapacityMWh",
"OnlinePowerCapacityMW", "OnlineEnergyCapacityMWh" ),
values=lambda m, (proj, bld_yr): (
proj, bld_yr, m.proj_load_zone[proj],
m.BuildProj[proj, bld_yr], m.BuildStorageEnergyMWh[proj, bld_yr],
m.ProjCapacity[proj, bld_yr], m.StorageEnergyCapacity[proj, bld_yr]
))
export.write_table(
instance, instance.STORAGE_PROJ_DISPATCH_POINTS,
output_file=os.path.join(outdir, "storage_dispatch.txt"),
headings=("project", "timepoint", "load_zone",
"ChargeMW", "DischargeMW", "StateOfChargeMWh"),
values=lambda m, (proj, t): (
proj, m.tp_timestamp[t], m.proj_load_zone[proj],
m.ChargeStorage[proj, t], m.DispatchProj[proj, t],
m.StateOfChargeMWh[proj, t]
))
def post_solve(instance, outdir):
"""
Export storage build information to storage_builds.txt, and storage
dispatch info to storage_dispatch.txt
"""
import switch_mod.export as export
export.write_table(
instance,
instance.STORAGE_PROJECT_BUILDYEARS,
output_file=os.path.join(outdir, "storage_builds.txt"),
headings=("project", "period", "load_zone",
"IncrementalPowerCapacityMW", "IncrementalEnergyCapacityMWh",
"OnlinePowerCapacityMW", "OnlineEnergyCapacityMWh"),
values=lambda m, (proj, bld_yr):
(proj, bld_yr, m.proj_load_zone[proj], m.BuildProj[proj, bld_yr], m.
BuildStorageEnergyMWh[proj, bld_yr], m.ProjCapacity[
proj, bld_yr], m.StorageEnergyCapacity[proj, bld_yr]))
export.write_table(
instance,
instance.STORAGE_PROJ_DISPATCH_POINTS,
output_file=os.path.join(outdir, "storage_dispatch.txt"),
headings=("project", "timepoint", "load_zone", "ChargeMW",
"DischargeMW", "StateOfChargeMWh"),
values=lambda m, (proj, t):
(proj, m.tp_timestamp[t], m.proj_load_zone[proj], m.ChargeStorage[
proj, t], m.DispatchProj[proj, t], m.StateOfChargeMWh[proj, t]))
def save_results(model, instance, outdir):
"""
Export results to standard files.
This initial placeholder version is integrating snippets of
some of Matthias's code into the main codebase.
"""
import switch_mod.export as export
export.write_table(
instance,
instance.LOAD_ZONES,
instance.TIMEPOINTS,
output_file=os.path.join(outdir, "load_balance.txt"),
headings=(
"load_zone",
"timestamp",
) + tuple(instance.LZ_Energy_Components_Produce +
instance.LZ_Energy_Components_Consume),
values=lambda m, lz, t: (
lz,
m.tp_timestamp[t],
) + tuple(
getattr(m, component)[lz, t] for component in
(m.LZ_Energy_Components_Produce + m.LZ_Energy_Components_Consume)))
def post_solve(instance, outdir):
"""
Default export of project dispatch per timepoint in tabular format.
"""
import switch_mod.export as export
export.write_table(
instance, instance.TIMEPOINTS,
output_file=os.path.join(outdir, "dispatch.txt"),
headings=("timestamp",)+tuple(instance.PROJECTS),
values=lambda m, t: (m.tp_timestamp[t],) + tuple(
m.DispatchProj[p, t] if (p, t) in m.PROJ_DISPATCH_POINTS
else 0.0
for p in m.PROJECTS
)
)
def post_solve(instance, outdir):
"""
Default export of project dispatch per timepoint in tabular format.
"""
import switch_mod.export as export
export.write_table(
instance, instance.TIMEPOINTS,
output_file=os.path.join(outdir, "dispatch.txt"),
headings=("timestamp",)+tuple(instance.PROJECTS),
values=lambda m, t: (m.tp_timestamp[t],) + tuple(
m.DispatchProj[p, t] if (p, t) in m.PROJ_DISPATCH_POINTS
else 0.0
for p in m.PROJECTS
)
)
def post_solve(instance, outdir):
"""
Default export of energy balance per node and timepoint in tabular format.
"""
import switch_mod.export as export
export.write_table(
instance, instance.LOAD_ZONES, instance.TIMEPOINTS,
output_file=os.path.join(outdir, "load_balance.txt"),
headings=("load_zone", "timestamp",) + tuple(
instance.LZ_Energy_Components_Produce +
instance.LZ_Energy_Components_Consume),
values=lambda m, lz, t: (lz, m.tp_timestamp[t],) + tuple(
getattr(m, component)[lz, t]
for component in (
m.LZ_Energy_Components_Produce +
m.LZ_Energy_Components_Consume)))
def save_results(model, instance, outdir):
"""
Export results to standard files.
"""
import switch_mod.export as export
export.write_table(
instance, instance.LOAD_ZONES, instance.TIMEPOINTS,
output_file=os.path.join(outdir, "load_balance2.txt"),
headings=("load_zone", "timestamp",) + tuple(
instance.LZ_Energy_Components_Produce +
instance.LZ_Energy_Components_Consume),
values=lambda m, lz, t: (lz, m.tp_timestamp[t],) + tuple(
getattr(m, component)[lz, t]
for component in (
m.LZ_Energy_Components_Produce +
m.LZ_Energy_Components_Consume)))
def save_results(model, instance, outdir):
"""
Export results to standard files.
This initial placeholder version is integrating snippets of
some of Matthias's code into the main codebase.
"""
import switch_mod.export as export
export.write_table(
instance,
instance.TIMEPOINTS,
output_file=os.path.join(outdir, "dispatch.txt"),
headings=("timestamp", ) + tuple(instance.PROJECTS),
values=lambda m, t:
(m.tp_timestamp[t], ) + tuple(m.DispatchProj[p, t] if
(p, t) in m.PROJ_DISPATCH_POINTS else 0.0
for p in m.PROJECTS))
def save_results(model, instance, outdir):
"""
Export results to standard files.
This initial placeholder version is integrating snippets of
some of Matthias's code into the main codebase.
"""
import switch_mod.export as export
export.write_table(
instance, instance.TIMEPOINTS,
output_file=os.path.join(outdir, "dispatch.txt"),
headings=("timestamp",)+tuple(instance.PROJECTS),
values=lambda m, t: (m.tp_timestamp[t],) + tuple(
m.DispatchProj[p, t] if (p, t) in m.PROJ_DISPATCH_POINTS
else 0.0
for p in m.PROJECTS
)
)
def save_results(model, instance, outdir):
"""
Export results to standard files.
This initial placeholder version is integrating snippets of
some of Matthias's code into the main codebase.
"""
import switch_mod.export as export
export.write_table(
instance, instance.TIMEPOINTS,
output_file=os.path.join("outputs", "load_balance.txt"),
headings=("timestamp",) + tuple(
instance.LZ_Energy_Balance_components),
values=lambda m, t: (m.tp_timestamp[t],) + tuple(
sum(getattr(m, component)[lz, t] for lz in m.LOAD_ZONES)
for component in m.LZ_Energy_Balance_components
)
)
def post_solve(instance, outdir):
"""
Export results to standard files.
"""
import switch_mod.export as export
export.write_table(
instance,
instance.LOAD_ZONES,
instance.TIMEPOINTS,
output_file=os.path.join(outdir, "load_balance2.txt"),
headings=(
"load_zone",
"timestamp",
) + tuple(instance.LZ_Energy_Components_Produce +
instance.LZ_Energy_Components_Consume),
values=lambda m, lz, t: (
lz,
m.tp_timestamp[t],
) + tuple(
getattr(m, component)[lz, t] for component in
(m.LZ_Energy_Components_Produce + m.LZ_Energy_Components_Consume)))
def post_solve(instance, outdir):
summaries_dir = os.path.join(outdir,"Summaries")
if not os.path.exists(summaries_dir):
os.makedirs(summaries_dir)
print "\nStarting to print summaries"
start=time.time()
if instance.options.export_marginal_costs:
"""
This table writes out the marginal costs of supplying energy in each timepoint in US$/MWh.
"""
print "marginal_costs_lz_tp.csv..."
export.write_table(
instance, instance.TIMEPOINTS, instance.LOAD_ZONES,
output_file=os.path.join(summaries_dir, "marginal_costs_lz_tp.csv"),
headings=("timepoint","load_zones","marginal_cost"),
values=lambda m, tp, lz: (m.tp_timestamp[tp], lz, m.dual[m.Energy_Balance[lz, tp]] / (m.tp_weight_in_year[tp] * uniform_series_to_present_value(
m.discount_rate, m.period_length_years[m.tp_period[tp]]) * future_to_present_value(
m.discount_rate, (m.period_start[m.tp_period[tp]] - m.base_financial_year)))
))
df = pd.read_csv('outputs/Summaries/marginal_costs_lz_tp.csv',sep='\t')
lz_dfs = []
for lz in instance.LOAD_ZONES:
lz_dfs.append(df[df.load_zones == lz].drop(['load_zones','timepoint'],axis=1).reset_index(drop=True))
lz_dfs[-1].columns = [lz]
DF = pd.concat(lz_dfs, axis=1)
fig = plt.figure(1)
mc_ax = fig.add_subplot(211)
# GO cycling through the rainbow to get line colours
cm = plt.get_cmap('gist_rainbow')
# You have to play with the color map and the line style list to get enough combinations for your particular plot
mc_ax.set_prop_cycle(cycler('linestyle',['-',':','--','-.']) * cycler('color',[cm(i/5.0) for i in range(0,6)]))
# to locate the legend: "loc" is the point of the legend for which you will specify cooridnates. These coords are specified in bbox_to_anchor (can be only 1 point or couple)
mc_plot = DF.plot(ax=mc_ax,linewidth=1.5).legend(loc='upper center', fontsize=10, bbox_to_anchor=(0.,-0.15,1.,-0.15), ncol=3, mode="expand")
plt.xticks([i*24 for i in range(1,len(instance.TIMEPOINTS)/24+1)],[instance.tp_timestamp[instance.TIMEPOINTS[i*24]] for i in range(1,len(instance.TIMEPOINTS)/24+1)],rotation=40,fontsize=7)
plt.savefig('outputs/Summaries/marginal_costs.pdf',bbox_extra_artists=(mc_plot,))
"""
This table writes out the fuel consumption in MMBTU per hour.
"""
# print "energy_produced_in_period_by_each_project.csv..."
# export.write_table(
# instance, instance.PERIODS, instance.PROJECTS,
# output_file=os.path.join(summaries_dir, "energy_produced_in_period_by_each_project.csv"),
# headings=("period", "project", "energy_produced_GWh"),
# values=lambda m, p, proj: (p, proj,) + tuple(
# sum(m.DispatchProj[proj,tp]*m.tp_weight[tp] for tp in m.PERIOD_TPS[p])/1000)
# )
# """
# This table writes out the fuel consumption in MMBTU per hour.
# """
# print "fuel_consumption_tp_hourly.csv..."
# export.write_table(
# instance, instance.TIMEPOINTS,
# output_file=os.path.join(summaries_dir, "fuel_consumption_tp_hourly.csv"),
# headings=("timepoint",) + tuple(f for f in instance.FUELS),
# values=lambda m, tp: (m.tp_timestamp[tp],) + tuple(
# sum(m.ProjFuelUseRate[proj, t, f] for (proj,t) in m.PROJ_WITH_FUEL_DISPATCH_POINTS
# if m.g_energy_source[m.proj_gen_tech[proj]] == f and t == tp)
# for f in m.FUELS)
# )
# """
# This table writes out the fuel consumption in total MMBTU consumed in each period.
# """
# print "fuel_consumption_periods_total.csv..."
# export.write_table(
# instance, instance.PERIODS,
# output_file=os.path.join(summaries_dir, "fuel_consumption_periods_total.csv"),
# headings=("period",) + tuple(f for f in instance.FUELS),
# values=lambda m, p: (p,) + tuple(
# sum(m.ProjFuelUseRate[proj, tp, f] * m.tp_weight[tp] for (proj, tp) in m.PROJ_WITH_FUEL_DISPATCH_POINTS
# if tp in m.PERIOD_TPS[p] and m.g_energy_source[m.proj_gen_tech[proj]] == f)
# for f in m.FUELS)
# )
if instance.options.export_capacities:
"""
This table writes out the capacity that it available in each period
by technology.
"""
print "build_proj_by_tech_p.csv..."
export.write_table(
instance, instance.GENERATION_TECHNOLOGIES,
output_file=os.path.join(summaries_dir, "build_proj_by_tech_p.csv"),
headings=("gentech","Legacy") + tuple(p for p in instance.PERIODS),
values=lambda m, g: (g, sum(m.BuildProj[proj, bldyr] for (proj, bldyr) in m.PROJECT_BUILDYEARS
if m.proj_gen_tech[proj] == g and bldyr not in m.PERIODS)) + tuple(
sum(m.ProjCapacity[proj, p] for proj in m.PROJECTS if m.proj_gen_tech[proj] == g)
for p in m.PERIODS)
)
DF = pd.read_csv('outputs/Summaries/build_proj_by_tech_p.csv',sep='\t').transpose()
DF.columns = DF.iloc[0]
DF=DF.drop('gentech')
fig = plt.figure(2)
tech_ax = fig.add_subplot(211)
# GO cycling through the rainbow to get line colours
cm = plt.get_cmap('gist_rainbow')
# You have to play with the color map and the line style list to get enough combinations for your particular plot
tech_ax.set_prop_cycle(cycler('color',[cm(i/7.0) for i in range(0,8)]))
# to locate the legend: "loc" is the point of the legend for which you will specify cooridnates. These coords are specified in bbox_to_anchor (can be only 1 point or couple)
tech_plot = DF.plot(ax=tech_ax,kind='bar').legend(loc='upper center', fontsize=10, bbox_to_anchor=(0.,-0.07,1.,-0.07), ncol=2, mode="expand")
plt.xticks(rotation=0,fontsize=12)
plt.savefig('outputs/Summaries/gentech_capacities.pdf',bbox_extra_artists=(tech_plot,))
if instance.options.export_tech_dispatch:
"""
This table writes out the aggregated dispatch of each gen tech on each timepoint.
"""
print "dispatch_proj_by_tech_tp.csv..."
export.write_table(
instance, instance.TIMEPOINTS,
output_file=os.path.join(summaries_dir, "dispatch_proj_by_tech_tp.csv"),
headings=("gentech",) + tuple(g for g in instance.GENERATION_TECHNOLOGIES) + ("total",),
values=lambda m, tp: (m.tp_timestamp[tp],) + tuple(
sum(m.DispatchProj[proj, t] for (proj, t) in m.PROJ_DISPATCH_POINTS
if m.proj_gen_tech[proj] == g and t == tp)
for g in m.GENERATION_TECHNOLOGIES) + (
sum(m.DispatchProj[proj, t] for (proj, t) in m.PROJ_DISPATCH_POINTS if t == tp),)
)
DF = pd.read_csv('outputs/Summaries/dispatch_proj_by_tech_tp.csv',sep='\t').drop(['gentech'],axis=1)
fig = plt.figure(3)
dis_ax = fig.add_subplot(211)
# GO cycling through the rainbow to get line colours
cm = plt.get_cmap('gist_rainbow')
# You have to play with the color map and the line style list to get enough combinations for your particular plot
dis_ax.set_prop_cycle(cycler('linestyle',['-','--',':']) * cycler('color',[cm(i/5.0) for i in range(0,6)]))
# to locate the legend: "loc" is the point of the legend for which you will specify cooridnates. These coords are specified in bbox_to_anchor (can be only 1 point or couple)
dis_plot = DF.plot(ax=dis_ax,linewidth=1.5).legend(loc='upper center', fontsize=10, bbox_to_anchor=(0.,-0.15,1.,-0.15), ncol=2, mode="expand")
plt.xticks([i*5 for i in range(1,len(instance.TIMEPOINTS)/5+1)],[instance.tp_timestamp[instance.TIMEPOINTS[i*5]] for i in range(1,len(instance.TIMEPOINTS)/5+1)],rotation=40,fontsize=7)
plt.savefig('outputs/Summaries/gentech_dispatch.pdf',bbox_extra_artists=(dis_plot,))
if instance.options.export_reservoirs:
"""
This table writes out reservoir levels in cubic meters per tp.
"""
print "reservoir_final_vols_tp.csv..."
export.write_table(
instance, instance.TIMEPOINTS,
output_file=os.path.join(summaries_dir, "reservoir_final_vols_tp.csv"),
headings=("timepoints",) + tuple(r for r in instance.RESERVOIRS) + ("total",),
values=lambda m, tp: (m.tp_timestamp[tp],) + tuple(m.ReservoirFinalvol[r, tp] - m.initial_res_vol[r] for r in m.RESERVOIRS) + (
sum(m.ReservoirFinalvol[r, tp] - m.initial_res_vol[r] for r in m.RESERVOIRS),)
)
DF = pd.read_csv('outputs/Summaries/reservoir_final_vols_tp.csv',sep='\t').drop(['timepoints'],axis=1)
fig2 = plt.figure(4)
res_ax = fig2.add_subplot(211)
# GO cycling through the rainbow to get line colours
cm = plt.get_cmap('gist_rainbow')
# You have to play with the color map and the line style list to get enough combinations for your particular plot
res_ax.set_prop_cycle(cycler('linestyle',['-',':','--']) * cycler('color',[cm(i/5.0) for i in range(0,6)]))
# to locate the legend: "loc" is the point of the legend for which you will specify cooridnates. These coords are specified in bbox_to_anchor (can be only 1 point or couple)
res_plot = DF.plot(ax=res_ax,linewidth=1.5).legend(loc='upper center', fontsize=10, bbox_to_anchor=(0.,-0.15,1.,-0.15), ncol=2, mode="expand")
plt.xticks([i*24 for i in range(1,len(instance.TIMEPOINTS)/24+1)],[instance.tp_timestamp[instance.TIMEPOINTS[i*24]] for i in range(1,len(instance.TIMEPOINTS)/24+1)],rotation=40,fontsize=7)
plt.savefig('outputs/Summaries/reservoir_levels.pdf',bbox_extra_artists=(res_plot,))
"""
Writing Objective Function value.
"""
print "total_system_costs.txt..."
with open(os.path.join(summaries_dir, "total_system_costs.txt"),'w+') as f:
f.write("Total System Costs: "+str(instance.SystemCost())+"\n")
f.write("Total Investment Costs: "+str(instance.TotalInvestmentCost())+"\n")
f.write("Total Operations Costs: "+str(instance.TotalOperationsCost()))
# # This table writes out the dispatch of each gen tech on each timepoint and load zone.
# #This process is extremely slow, need to make it efficient
# print "dispatch_proj_by_tech_lz_tp.csv..."
# export.write_table(
# instance, instance.TIMEPOINTS, instance.LOAD_ZONES,
# output_file=os.path.join(summaries_dir, "dispatch_proj_by_tech_lz_tp.csv"),
# headings=("load zone", "timepoint",) + tuple(g for g in instance.GENERATION_TECHNOLOGIES),
# values=lambda m, tp, lz: (lz, m.tp_timestamp[tp],) + tuple(
# sum(m.DispatchProj[proj, t] for (proj, t) in m.PROJ_DISPATCH_POINTS
# if m.proj_gen_tech[proj] == g and t == tp and m.proj_load_zone[proj] == lz)
# for g in m.GENERATION_TECHNOLOGIES)
# )
print "Time taken writing summaries: {dur:.2f}s".format(dur=time.time()-start)
