def minmax_cost_optimization(backend_model, cost_class, sense):
"""
Minimize or maximise total system cost for specified cost class.
If unmet_demand is in use, then the calculated cost of unmet_demand is
added or subtracted from the total cost in the opposite sense to the
objective.
.. container:: scrolling-wrapper
.. math::
min: z = \sum_{loc::tech_{cost}} cost(loc::tech, cost=cost_{k})) + \sum_{loc::carrier,timestep} unmet\_demand(loc::carrier, timestep) \\times bigM
max: z = \sum_{loc::tech_{cost}} cost(loc::tech, cost=cost_{k})) - \sum_{loc::carrier,timestep} unmet\_demand(loc::carrier, timestep) \\times bigM
"""
def obj_rule(backend_model):
if hasattr(backend_model, 'unmet_demand'):
unmet_demand = sum(
backend_model.unmet_demand[loc_carrier, timestep]
for loc_carrier in backend_model.loc_carriers
for timestep in backend_model.timesteps) * backend_model.bigM
if sense == 'maximize':
unmet_demand *= -1
else:
unmet_demand = 0
return (sum(backend_model.cost[cost_class, loc_tech]
for loc_tech in backend_model.loc_techs_cost) +
unmet_demand)
backend_model.obj = po.Objective(sense=load_function('pyomo.core.' +
sense),
rule=obj_rule)
backend_model.obj.domain = po.Reals
def cost_minimization(backend_model):
"""
Minimizes total system monetary cost.
.. container:: scrolling-wrapper
.. math::
min: z = \sum_{loc::tech_{cost}} cost(loc::tech, cost=cost_{monetary})) + \sum_{loc::carrier,timestep} unmet\_demand(loc::carrier, timestep) \\times bigM
"""
def obj_rule(backend_model):
if hasattr(backend_model, 'unmet_demand'):
unmet_demand = sum(
backend_model.unmet_demand[loc_carrier, timestep]
for loc_carrier in backend_model.loc_carriers
for timestep in backend_model.timesteps) * backend_model.bigM
else:
unmet_demand = 0
return (sum(backend_model.cost['monetary', loc_tech]
for loc_tech in backend_model.loc_techs_cost) +
unmet_demand)
backend_model.obj = po.Objective(sense=po.minimize, rule=obj_rule)
backend_model.obj.domain = po.Reals
def check_feasibility(backend_model):
"""
Dummy objective, to check that there are no conflicting constraints.
"""
def obj_rule(backend_model):
return 1
backend_model.obj = po.Objective(sense=po.minimize, rule=obj_rule)
backend_model.obj.domain = po.Reals
def minmax_cost_optimization(backend_model):
"""
Minimize or maximise total system cost for specified cost class or a set of cost classes.
cost_class is a string or dictionary. If a string, it is automatically converted to a
dictionary with a single key:value pair where value == 1. The dictionary provides a weight
for each cost class of interest: {cost_1: weight_1, cost_2: weight_2, etc.}.
If unmet_demand is in use, then the calculated cost of unmet_demand is
added or subtracted from the total cost in the opposite sense to the
objective.
.. container:: scrolling-wrapper
.. math::
min: z = \\sum_{loc::tech_{cost},k} (cost(loc::tech, cost=cost_{k}) \\times weight_{k}) +
\\sum_{loc::carrier,timestep} (unmet\\_demand(loc::carrier, timestep) \\times bigM)
max: z = \\sum_{loc::tech_{cost},k} (cost(loc::tech, cost=cost_{k}) \\times weight_{k}) -
\\sum_{loc::carrier,timestep} (unmet\\_demand(loc::carrier, timestep) \\times bigM)
"""
def obj_rule(backend_model):
if backend_model.__calliope_run_config.get("ensure_feasibility",
False):
unmet_demand = (po.quicksum(
(backend_model.unmet_demand[carrier, node, timestep] -
backend_model.unused_supply[carrier, node, timestep]) *
backend_model.timestep_weights[timestep]
for [carrier, node, timestep] in backend_model.carriers *
backend_model.nodes * backend_model.timesteps
if [carrier, node, timestep] in
backend_model.unmet_demand._index) * backend_model.bigM)
if backend_model.objective_sense == "maximize":
unmet_demand *= -1
else:
unmet_demand = 0
return (po.quicksum(
po.quicksum(
backend_model.cost[class_name, node, tech]
for [node, tech] in backend_model.nodes * backend_model.techs
if [class_name, node, tech] in backend_model.cost._index) *
weight for class_name, weight in
backend_model.objective_cost_class.items()) + unmet_demand)
backend_model.obj = po.Objective(
sense=load_function("pyomo.core." + backend_model.objective_sense),
rule=obj_rule,
)
backend_model.obj.domain = po.Reals
def objective_cost_minimization(model):
"""
Minimizes total system monetary cost.
Used as a default if a model does not specify another objective.
"""
m = model.m
def obj_rule(m):
return sum(
model.get_option(y + '.weight') * sum(m.cost[y, x, 'monetary']
for x in m.x) for y in m.y)
m.obj = po.Objective(sense=po.minimize, rule=obj_rule)
m.obj.domain = po.Reals
def check_feasibility(backend_model):
"""
Dummy objective, to check that there are no conflicting constraints.
.. container:: scrolling-wrapper
.. math::
min: z = 1
"""
def obj_rule(backend_model):
return 1
backend_model.obj = po.Objective(sense=po.minimize, rule=obj_rule)
backend_model.obj.domain = po.Reals
def minmax_cost_optimization(backend_model, cost_class, sense):
"""
Minimize or maximise total system cost for specified cost class or a set of cost classes.
cost_class is a string or dictionary. If a string, it is automatically converted to a
dictionary with a single key:value pair where value == 1. The dictionary provides a weight
for each cost class of interest: {cost_1: weight_1, cost_2: weight_2, etc.}.
If unmet_demand is in use, then the calculated cost of unmet_demand is
added or subtracted from the total cost in the opposite sense to the
objective.
.. container:: scrolling-wrapper
.. math::
min: z = \\sum_{loc::tech_{cost},k} (cost(loc::tech, cost=cost_{k}) \\times weight_{k}) +
\\sum_{loc::carrier,timestep} (unmet\\_demand(loc::carrier, timestep) \\times bigM)
max: z = \\sum_{loc::tech_{cost},k} (cost(loc::tech, cost=cost_{k}) \\times weight_{k}) -
\\sum_{loc::carrier,timestep} (unmet\\_demand(loc::carrier, timestep) \\times bigM)
"""
def obj_rule(backend_model):
nonlocal cost_class
if backend_model.__calliope_run_config.get('ensure_feasibility',
False):
unmet_demand = sum(
(backend_model.unmet_demand[loc_carrier, timestep] -
backend_model.unused_supply[loc_carrier, timestep]) *
backend_model.timestep_weights[timestep]
for loc_carrier in backend_model.loc_carriers
for timestep in backend_model.timesteps) * backend_model.bigM
if sense == 'maximize':
unmet_demand *= -1
else:
unmet_demand = 0
return (sum(backend_model.cost[k, loc_tech] * v
for loc_tech in backend_model.loc_techs_cost
for k, v in cost_class.items()) + unmet_demand)
backend_model.obj = po.Objective(sense=load_function('pyomo.core.' +
sense),
rule=obj_rule)
backend_model.obj.domain = po.Reals
def objective_cost_minimization(model):
"""
Minimizes total system monetary cost.
Used as a default if a model does not specify another objective.
"""
m = model.m
def get_y(loc_tech):
return loc_tech.split(":", 1)[1]
def obj_rule(m):
return sum(
model.get_option(get_y(loc_tech) + '.weight') *
m.cost[loc_tech, 'monetary'] for loc_tech in m.loc_tech)
m.obj = po.Objective(sense=po.minimize, rule=obj_rule)
m.obj.domain = po.Reals
def create_model(data, dt=1, timesteps=None, dual=False):
"""Create a pyomo ConcreteModel urbs object from given input data.
Args:
data: a dict of 6 DataFrames with the keys 'commodity', 'process',
'transmission', 'storage', 'demand' and 'supim'.
dt: timestep duration in hours (default: 1)
timesteps: optional list of timesteps, default: demand timeseries
dual: set True to add dual variables to model (slower); default: False
Returns:
a pyomo ConcreteModel object
"""
# Optional
if not timesteps:
timesteps = data['demand'].index.tolist()
m = pyomo_model_prep(data, timesteps) # preparing pyomo model
m.name = 'urbs'
m.created = datetime.now().strftime('%Y%m%dT%H%M')
m._data = data
# Parameters
# weight = length of year (hours) / length of simulation (hours)
# weight scales costs and emissions from length of simulation to a full
# year, making comparisons among cost types (invest is annualized, fixed
# costs are annual by default, variable costs are scaled by weight) and
# among different simulation durations meaningful.
m.weight = pyomo.Param(
initialize=float(8760) / (len(m.timesteps) * dt),
doc='Pre-factor for variable costs and emissions for an annual result')
# dt = spacing between timesteps. Required for storage equation that
# converts between energy (storage content, e_sto_con) and power (all other
# quantities that start with "e_")
m.dt = pyomo.Param(initialize=dt,
doc='Time step duration (in hours), default: 1')
# Sets
# ====
# Syntax: m.{name} = Set({domain}, initialize={values})
# where name: set name
# domain: set domain for tuple sets, a cartesian set product
# values: set values, a list or array of element tuples
# generate ordered time step sets
m.t = pyomo.Set(initialize=m.timesteps,
ordered=True,
doc='Set of timesteps')
# modelled (i.e. excluding init time step for storage) time steps
m.tm = pyomo.Set(within=m.t,
initialize=m.timesteps[1:],
ordered=True,
doc='Set of modelled timesteps')
# modelled Demand Side Management time steps (downshift):
# downshift effective in tt to compensate for upshift in t
m.tt = pyomo.Set(within=m.t,
initialize=m.timesteps[1:],
ordered=True,
doc='Set of additional DSM time steps')
# site (e.g. north, middle, south...)
m.sit = pyomo.Set(
initialize=m.commodity.index.get_level_values('Site').unique(),
doc='Set of sites')
# commodity (e.g. solar, wind, coal...)
m.com = pyomo.Set(
initialize=m.commodity.index.get_level_values('Commodity').unique(),
doc='Set of commodities')
# commodity type (i.e. SupIm, Demand, Stock, Env)
m.com_type = pyomo.Set(
initialize=m.commodity.index.get_level_values('Type').unique(),
doc='Set of commodity types')
# process (e.g. Wind turbine, Gas plant, Photovoltaics...)
m.pro = pyomo.Set(
initialize=m.process.index.get_level_values('Process').unique(),
doc='Set of conversion processes')
# tranmission (e.g. hvac, hvdc, pipeline...)
m.tra = pyomo.Set(initialize=m.transmission.index.get_level_values(
'Transmission').unique(),
doc='Set of transmission technologies')
# storage (e.g. hydrogen, pump storage)
m.sto = pyomo.Set(
initialize=m.storage.index.get_level_values('Storage').unique(),
doc='Set of storage technologies')
# cost_type
m.cost_type = pyomo.Set(initialize=[
'Invest', 'Fixed', 'Variable', 'Fuel', 'Revenue', 'Purchase',
'Environmental'
],
doc='Set of cost types (hard-coded)')
# tuple sets
m.com_tuples = pyomo.Set(
within=m.sit * m.com * m.com_type,
initialize=m.commodity.index,
doc='Combinations of defined commodities, e.g. (Mid,Elec,Demand)')
m.pro_tuples = pyomo.Set(
within=m.sit * m.pro,
initialize=m.process.index,
doc='Combinations of possible processes, e.g. (North,Coal plant)')
m.tra_tuples = pyomo.Set(
within=m.sit * m.sit * m.tra * m.com,
initialize=m.transmission.index,
doc='Combinations of possible transmissions, e.g. '
'(South,Mid,hvac,Elec)')
m.sto_tuples = pyomo.Set(
within=m.sit * m.sto * m.com,
initialize=m.storage.index,
doc='Combinations of possible storage by site, e.g. (Mid,Bat,Elec)')
m.dsm_site_tuples = pyomo.Set(
within=m.sit * m.com,
initialize=m.dsm.index,
doc='Combinations of possible dsm by site, e.g. (Mid, Elec)')
m.dsm_down_tuples = pyomo.Set(
within=m.tm * m.tm * m.sit * m.com,
initialize=[(t, tt, site, commodity)
for (t, tt, site, commodity) in dsm_down_time_tuples(
m.timesteps[1:], m.dsm_site_tuples, m)],
doc='Combinations of possible dsm_down combinations, e.g. '
'(5001,5003,Mid,Elec)')
# commodity type subsets
m.com_supim = pyomo.Set(
within=m.com,
initialize=commodity_subset(m.com_tuples, 'SupIm'),
doc='Commodities that have intermittent (timeseries) input')
m.com_stock = pyomo.Set(
within=m.com,
initialize=commodity_subset(m.com_tuples, 'Stock'),
doc='Commodities that can be purchased at some site(s)')
m.com_sell = pyomo.Set(within=m.com,
initialize=commodity_subset(m.com_tuples, 'Sell'),
doc='Commodities that can be sold')
m.com_buy = pyomo.Set(within=m.com,
initialize=commodity_subset(m.com_tuples, 'Buy'),
doc='Commodities that can be purchased')
m.com_demand = pyomo.Set(
within=m.com,
initialize=commodity_subset(m.com_tuples, 'Demand'),
doc='Commodities that have a demand (implies timeseries)')
m.com_env = pyomo.Set(
within=m.com,
initialize=commodity_subset(m.com_tuples, 'Env'),
doc='Commodities that (might) have a maximum creation limit')
# process tuples for area rule
m.pro_area_tuples = pyomo.Set(
within=m.sit * m.pro,
initialize=m.proc_area.index,
doc='Processes and Sites with area Restriction')
# process input/output
m.pro_input_tuples = pyomo.Set(
within=m.sit * m.pro * m.com,
initialize=[(site, process, commodity)
for (site, process) in m.pro_tuples
for (pro, commodity) in m.r_in.index if process == pro],
doc='Commodities consumed by process by site, e.g. (Mid,PV,Solar)')
m.pro_output_tuples = pyomo.Set(
within=m.sit * m.pro * m.com,
initialize=[(site, process, commodity)
for (site, process) in m.pro_tuples
for (pro, commodity) in m.r_out.index if process == pro],
doc='Commodities produced by process by site, e.g. (Mid,PV,Elec)')
# process tuples for maximum gradient feature
m.pro_maxgrad_tuples = pyomo.Set(
within=m.sit * m.pro,
initialize=[(sit, pro) for (sit, pro) in m.pro_tuples
if m.process.loc[sit, pro]['max-grad'] < 1.0 / dt],
doc='Processes with maximum gradient smaller than timestep length')
# process tuples for partial feature
m.pro_partial_tuples = pyomo.Set(within=m.sit * m.pro,
initialize=[
(site, process)
for (site, process) in m.pro_tuples
for (pro,
_) in m.r_in_min_fraction.index
if process == pro
],
doc='Processes with partial input')
m.pro_partial_input_tuples = pyomo.Set(
within=m.sit * m.pro * m.com,
initialize=[(site, process, commodity)
for (site, process) in m.pro_partial_tuples
for (pro, commodity) in m.r_in_min_fraction.index
if process == pro],
doc='Commodities with partial input ratio, e.g. (Mid,Coal PP,Coal)')
m.pro_partial_output_tuples = pyomo.Set(
within=m.sit * m.pro * m.com,
initialize=[(site, process, commodity)
for (site, process) in m.pro_partial_tuples
for (pro, commodity) in m.r_out_min_fraction.index
if process == pro],
doc='Commodities with partial input ratio, e.g. (Mid,Coal PP,CO2)')
# process tuples for time variable efficiency
m.pro_timevar_output_tuples = pyomo.Set(
within=m.sit * m.pro * m.com,
initialize=[(site, process, commodity)
for (site, process) in m.eff_factor.columns.values
for (pro, commodity) in m.r_out.index if process == pro],
doc='Outputs of processes with time dependent efficiency')
# Variables
# costs
m.costs = pyomo.Var(m.cost_type,
within=pyomo.Reals,
doc='Costs by type (EUR/a)')
# commodity
m.e_co_stock = pyomo.Var(
m.tm,
m.com_tuples,
within=pyomo.NonNegativeReals,
doc='Use of stock commodity source (MW) per timestep')
m.e_co_sell = pyomo.Var(
m.tm,
m.com_tuples,
within=pyomo.NonNegativeReals,
doc='Use of sell commodity source (MW) per timestep')
m.e_co_buy = pyomo.Var(m.tm,
m.com_tuples,
within=pyomo.NonNegativeReals,
doc='Use of buy commodity source (MW) per timestep')
# process
m.cap_pro = pyomo.Var(m.pro_tuples,
within=pyomo.NonNegativeReals,
doc='Total process capacity (MW)')
m.cap_pro_new = pyomo.Var(m.pro_tuples,
within=pyomo.NonNegativeReals,
doc='New process capacity (MW)')
m.tau_pro = pyomo.Var(m.t,
m.pro_tuples,
within=pyomo.NonNegativeReals,
doc='Power flow (MW) through process')
m.e_pro_in = pyomo.Var(
m.tm,
m.pro_tuples,
m.com,
within=pyomo.NonNegativeReals,
doc='Power flow of commodity into process (MW) per timestep')
m.e_pro_out = pyomo.Var(m.tm,
m.pro_tuples,
m.com,
within=pyomo.NonNegativeReals,
doc='Power flow out of process (MW) per timestep')
# transmission
m.cap_tra = pyomo.Var(m.tra_tuples,
within=pyomo.NonNegativeReals,
doc='Total transmission capacity (MW)')
m.cap_tra_new = pyomo.Var(m.tra_tuples,
within=pyomo.NonNegativeReals,
doc='New transmission capacity (MW)')
m.e_tra_in = pyomo.Var(
m.tm,
m.tra_tuples,
within=pyomo.NonNegativeReals,
doc='Power flow into transmission line (MW) per timestep')
m.e_tra_out = pyomo.Var(
m.tm,
m.tra_tuples,
within=pyomo.NonNegativeReals,
doc='Power flow out of transmission line (MW) per timestep')
# storage
m.cap_sto_c = pyomo.Var(m.sto_tuples,
within=pyomo.NonNegativeReals,
doc='Total storage size (MWh)')
m.cap_sto_c_new = pyomo.Var(m.sto_tuples,
within=pyomo.NonNegativeReals,
doc='New storage size (MWh)')
m.cap_sto_p = pyomo.Var(m.sto_tuples,
within=pyomo.NonNegativeReals,
doc='Total storage power (MW)')
m.cap_sto_p_new = pyomo.Var(m.sto_tuples,
within=pyomo.NonNegativeReals,
doc='New storage power (MW)')
m.e_sto_in = pyomo.Var(m.tm,
m.sto_tuples,
within=pyomo.NonNegativeReals,
doc='Power flow into storage (MW) per timestep')
m.e_sto_out = pyomo.Var(m.tm,
m.sto_tuples,
within=pyomo.NonNegativeReals,
doc='Power flow out of storage (MW) per timestep')
m.e_sto_con = pyomo.Var(m.t,
m.sto_tuples,
within=pyomo.NonNegativeReals,
doc='Energy content of storage (MWh) in timestep')
# demand side management
m.dsm_up = pyomo.Var(m.tm,
m.dsm_site_tuples,
within=pyomo.NonNegativeReals,
doc='DSM upshift')
m.dsm_down = pyomo.Var(m.dsm_down_tuples,
within=pyomo.NonNegativeReals,
doc='DSM downshift')
# Equation declarations
# equation bodies are defined in separate functions, referred to here by
# their name in the "rule" keyword.
# commodity
m.res_vertex = pyomo.Constraint(
m.tm,
m.com_tuples,
rule=res_vertex_rule,
doc='storage + transmission + process + source + buy - sell == demand')
m.res_stock_step = pyomo.Constraint(
m.tm,
m.com_tuples,
rule=res_stock_step_rule,
doc='stock commodity input per step <= commodity.maxperstep')
m.res_stock_total = pyomo.Constraint(
m.com_tuples,
rule=res_stock_total_rule,
doc='total stock commodity input <= commodity.max')
m.res_sell_step = pyomo.Constraint(
m.tm,
m.com_tuples,
rule=res_sell_step_rule,
doc='sell commodity output per step <= commodity.maxperstep')
m.res_sell_total = pyomo.Constraint(
m.com_tuples,
rule=res_sell_total_rule,
doc='total sell commodity output <= commodity.max')
m.res_buy_step = pyomo.Constraint(
m.tm,
m.com_tuples,
rule=res_buy_step_rule,
doc='buy commodity output per step <= commodity.maxperstep')
m.res_buy_total = pyomo.Constraint(
m.com_tuples,
rule=res_buy_total_rule,
doc='total buy commodity output <= commodity.max')
m.res_env_step = pyomo.Constraint(
m.tm,
m.com_tuples,
rule=res_env_step_rule,
doc='environmental output per step <= commodity.maxperstep')
m.res_env_total = pyomo.Constraint(
m.com_tuples,
rule=res_env_total_rule,
doc='total environmental commodity output <= commodity.max')
# process
m.def_process_capacity = pyomo.Constraint(
m.pro_tuples,
rule=def_process_capacity_rule,
doc='total process capacity = inst-cap + new capacity')
m.def_process_input = pyomo.Constraint(
m.tm,
m.pro_input_tuples - m.pro_partial_input_tuples,
rule=def_process_input_rule,
doc='process input = process throughput * input ratio')
m.def_process_output = pyomo.Constraint(
m.tm, (m.pro_output_tuples - m.pro_partial_output_tuples -
m.pro_timevar_output_tuples),
rule=def_process_output_rule,
doc='process output = process throughput * output ratio')
m.def_intermittent_supply = pyomo.Constraint(
m.tm,
m.pro_input_tuples,
rule=def_intermittent_supply_rule,
doc='process output = process capacity * supim timeseries')
m.res_process_throughput_by_capacity = pyomo.Constraint(
m.tm,
m.pro_tuples,
rule=res_process_throughput_by_capacity_rule,
doc='process throughput <= total process capacity')
m.res_process_maxgrad_lower = pyomo.Constraint(
m.tm,
m.pro_maxgrad_tuples,
rule=res_process_maxgrad_lower_rule,
doc='throughput may not decrease faster than maximal gradient')
m.res_process_maxgrad_upper = pyomo.Constraint(
m.tm,
m.pro_maxgrad_tuples,
rule=res_process_maxgrad_upper_rule,
doc='throughput may not increase faster than maximal gradient')
m.res_process_capacity = pyomo.Constraint(
m.pro_tuples,
rule=res_process_capacity_rule,
doc='process.cap-lo <= total process capacity <= process.cap-up')
m.res_area = pyomo.Constraint(
m.sit,
rule=res_area_rule,
doc='used process area <= total process area')
m.res_sell_buy_symmetry = pyomo.Constraint(
m.pro_input_tuples,
rule=res_sell_buy_symmetry_rule,
doc='power connection capacity must be symmetric in both directions')
m.res_throughput_by_capacity_min = pyomo.Constraint(
m.tm,
m.pro_partial_tuples,
rule=res_throughput_by_capacity_min_rule,
doc='cap_pro * min-fraction <= tau_pro')
m.def_partial_process_input = pyomo.Constraint(
m.tm,
m.pro_partial_input_tuples,
rule=def_partial_process_input_rule,
doc='e_pro_in = '
' cap_pro * min_fraction * (r - R) / (1 - min_fraction)'
' + tau_pro * (R - min_fraction * r) / (1 - min_fraction)')
m.def_partial_process_output = pyomo.Constraint(
m.tm, (m.pro_partial_output_tuples -
(m.pro_partial_output_tuples & m.pro_timevar_output_tuples)),
rule=def_partial_process_output_rule,
doc='e_pro_out = '
' cap_pro * min_fraction * (r - R) / (1 - min_fraction)'
' + tau_pro * (R - min_fraction * r) / (1 - min_fraction)')
m.def_process_timevar_output = pyomo.Constraint(
m.tm, (m.pro_timevar_output_tuples -
(m.pro_partial_output_tuples & m.pro_timevar_output_tuples)),
rule=def_pro_timevar_output_rule,
doc='e_pro_out = tau_pro * r_out * eff_factor')
m.def_process_partial_timevar_output = pyomo.Constraint(
m.tm,
m.pro_partial_output_tuples & m.pro_timevar_output_tuples,
rule=def_pro_partial_timevar_output_rule,
doc='e_pro_out = tau_pro * r_out * eff_factor')
# transmission
m.def_transmission_capacity = pyomo.Constraint(
m.tra_tuples,
rule=def_transmission_capacity_rule,
doc='total transmission capacity = inst-cap + new capacity')
m.def_transmission_output = pyomo.Constraint(
m.tm,
m.tra_tuples,
rule=def_transmission_output_rule,
doc='transmission output = transmission input * efficiency')
m.res_transmission_input_by_capacity = pyomo.Constraint(
m.tm,
m.tra_tuples,
rule=res_transmission_input_by_capacity_rule,
doc='transmission input <= total transmission capacity')
m.res_transmission_capacity = pyomo.Constraint(
m.tra_tuples,
rule=res_transmission_capacity_rule,
doc='transmission.cap-lo <= total transmission capacity <= '
'transmission.cap-up')
m.res_transmission_symmetry = pyomo.Constraint(
m.tra_tuples,
rule=res_transmission_symmetry_rule,
doc='total transmission capacity must be symmetric in both directions')
# storage
m.def_storage_state = pyomo.Constraint(
m.tm,
m.sto_tuples,
rule=def_storage_state_rule,
doc='storage[t] = (1 - sd) * storage[t-1] + in * eff_i - out / eff_o')
m.def_storage_power = pyomo.Constraint(
m.sto_tuples,
rule=def_storage_power_rule,
doc='storage power = inst-cap + new power')
m.def_storage_capacity = pyomo.Constraint(
m.sto_tuples,
rule=def_storage_capacity_rule,
doc='storage capacity = inst-cap + new capacity')
m.res_storage_input_by_power = pyomo.Constraint(
m.tm,
m.sto_tuples,
rule=res_storage_input_by_power_rule,
doc='storage input <= storage power')
m.res_storage_output_by_power = pyomo.Constraint(
m.tm,
m.sto_tuples,
rule=res_storage_output_by_power_rule,
doc='storage output <= storage power')
m.res_storage_state_by_capacity = pyomo.Constraint(
m.t,
m.sto_tuples,
rule=res_storage_state_by_capacity_rule,
doc='storage content <= storage capacity')
m.res_storage_power = pyomo.Constraint(
m.sto_tuples,
rule=res_storage_power_rule,
doc='storage.cap-lo-p <= storage power <= storage.cap-up-p')
m.res_storage_capacity = pyomo.Constraint(
m.sto_tuples,
rule=res_storage_capacity_rule,
doc='storage.cap-lo-c <= storage capacity <= storage.cap-up-c')
m.res_initial_and_final_storage_state = pyomo.Constraint(
m.t,
m.sto_tuples,
rule=res_initial_and_final_storage_state_rule,
doc='storage content initial == and final >= storage.init * capacity')
# costs
m.def_costs = pyomo.Constraint(m.cost_type,
rule=def_costs_rule,
doc='main cost function by cost type')
m.obj = pyomo.Objective(rule=obj_rule,
sense=pyomo.minimize,
doc='minimize(cost = sum of all cost types)')
# demand side management
m.def_dsm_variables = pyomo.Constraint(
m.tm,
m.dsm_site_tuples,
rule=def_dsm_variables_rule,
doc='DSMup * efficiency factor n == DSMdo (summed)')
m.res_dsm_upward = pyomo.Constraint(
m.tm,
m.dsm_site_tuples,
rule=res_dsm_upward_rule,
doc='DSMup <= Cup (threshold capacity of DSMup)')
m.res_dsm_downward = pyomo.Constraint(
m.tm,
m.dsm_site_tuples,
rule=res_dsm_downward_rule,
doc='DSMdo (summed) <= Cdo (threshold capacity of DSMdo)')
m.res_dsm_maximum = pyomo.Constraint(
m.tm,
m.dsm_site_tuples,
rule=res_dsm_maximum_rule,
doc='DSMup + DSMdo (summed) <= max(Cup,Cdo)')
m.res_dsm_recovery = pyomo.Constraint(
m.tm,
m.dsm_site_tuples,
rule=res_dsm_recovery_rule,
doc='DSMup(t, t + recovery time R) <= Cup * delay time L')
m.res_global_co2_limit = pyomo.Constraint(
rule=res_global_co2_limit_rule,
doc='total co2 commodity output <= Global CO2 limit')
if dual:
m.dual = pyomo.Suffix(direction=pyomo.Suffix.IMPORT)
return m
def create_model(data, dt=1, timesteps=None, objective='cost', dual=True):
"""Create a pyomo ConcreteModel urbs object from given input data.
Args:
- data: a dict of up to 12
- dt: timestep duration in hours (default: 1)
- timesteps: optional list of timesteps, default: demand timeseries
- objective: Either "cost" or "CO2" for choice of objective function,
default: "cost"
- dual: set True to add dual variables to model output
(marginally slower), default: True
Returns:
a pyomo ConcreteModel object
"""
# Optional
if not timesteps:
timesteps = data['demand'].index.tolist()
m = pyomo_model_prep(data, timesteps) # preparing pyomo model
m.name = 'urbs'
m.created = datetime.now().strftime('%Y%m%dT%H%M')
m._data = data
# Parameters
# weight = length of year (hours) / length of simulation (hours)
# weight scales costs and emissions from length of simulation to a full
# year, making comparisons among cost types (invest is annualized, fixed
# costs are annual by default, variable costs are scaled by weight) and
# among different simulation durations meaningful.
m.weight = pyomo.Param(
initialize=float(8760) / (len(m.timesteps) * dt),
doc='Pre-factor for variable costs and emissions for an annual result')
# dt = spacing between timesteps. Required for storage equation that
# converts between energy (storage content, e_sto_con) and power (all other
# quantities that start with "e_")
m.dt = pyomo.Param(initialize=dt,
doc='Time step duration (in hours), default: 1')
# import objective function information
m.obj = pyomo.Param(
initialize=objective,
doc='Specification of minimized quantity, default: "cost"')
# Sets
# ====
# Syntax: m.{name} = Set({domain}, initialize={values})
# where name: set name
# domain: set domain for tuple sets, a cartesian set product
# values: set values, a list or array of element tuples
# generate ordered time step sets
m.t = pyomo.Set(initialize=m.timesteps,
ordered=True,
doc='Set of timesteps')
# modelled (i.e. excluding init time step for storage) time steps
m.tm = pyomo.Set(within=m.t,
initialize=m.timesteps[1:],
ordered=True,
doc='Set of modelled timesteps')
# support timeframes (e.g. 2020, 2030...)
indexlist = set()
for key in m.commodity_dict["price"]:
indexlist.add(tuple(key)[0])
m.stf = pyomo.Set(initialize=indexlist,
doc='Set of modeled support timeframes (e.g. years)')
# site (e.g. north, middle, south...)
indexlist = set()
for key in m.commodity_dict["price"]:
indexlist.add(tuple(key)[1])
m.sit = pyomo.Set(initialize=indexlist, doc='Set of sites')
# commodity (e.g. solar, wind, coal...)
indexlist = set()
for key in m.commodity_dict["price"]:
indexlist.add(tuple(key)[2])
m.com = pyomo.Set(initialize=indexlist, doc='Set of commodities')
# commodity type (i.e. SupIm, Demand, Stock, Env)
indexlist = set()
for key in m.commodity_dict["price"]:
indexlist.add(tuple(key)[3])
m.com_type = pyomo.Set(initialize=indexlist, doc='Set of commodity types')
# process (e.g. Wind turbine, Gas plant, Photovoltaics...)
indexlist = set()
for key in m.process_dict["inv-cost"]:
indexlist.add(tuple(key)[2])
m.pro = pyomo.Set(initialize=indexlist, doc='Set of conversion processes')
# cost_type
m.cost_type = pyomo.Set(initialize=m.cost_type_list,
doc='Set of cost types (hard-coded)')
# tuple sets
m.sit_tuples = pyomo.Set(
within=m.stf * m.sit,
initialize=tuple(m.site_dict["area"].keys()),
doc='Combinations of support timeframes and sites')
m.com_tuples = pyomo.Set(
within=m.stf * m.sit * m.com * m.com_type,
initialize=tuple(m.commodity_dict["price"].keys()),
doc='Combinations of defined commodities, e.g. (2018,Mid,Elec,Demand)')
m.pro_tuples = pyomo.Set(
within=m.stf * m.sit * m.pro,
initialize=tuple(m.process_dict["inv-cost"].keys()),
doc='Combinations of possible processes, e.g. (2018,North,Coal plant)')
m.com_stock = pyomo.Set(
within=m.com,
initialize=commodity_subset(m.com_tuples, 'Stock'),
doc='Commodities that can be purchased at some site(s)')
if m.mode['int']:
# tuples for operational status of technologies
m.operational_pro_tuples = pyomo.Set(
within=m.sit * m.pro * m.stf * m.stf,
initialize=[(sit, pro, stf, stf_later)
for (sit, pro, stf,
stf_later) in op_pro_tuples(m.pro_tuples, m)],
doc='Processes that are still operational through stf_later'
'(and the relevant years following), if built in stf'
'in stf.')
# tuples for rest lifetime of installed capacities of technologies
m.inst_pro_tuples = pyomo.Set(
within=m.sit * m.pro * m.stf,
initialize=[(sit, pro, stf)
for (sit, pro, stf) in inst_pro_tuples(m)],
doc='Installed processes that are still operational through stf')
# commodity type subsets
m.com_supim = pyomo.Set(
within=m.com,
initialize=commodity_subset(m.com_tuples, 'SupIm'),
doc='Commodities that have intermittent (timeseries) input')
m.com_demand = pyomo.Set(
within=m.com,
initialize=commodity_subset(m.com_tuples, 'Demand'),
doc='Commodities that have a demand (implies timeseries)')
m.com_env = pyomo.Set(
within=m.com,
initialize=commodity_subset(m.com_tuples, 'Env'),
doc='Commodities that (might) have a maximum creation limit')
# process tuples for area rule
m.pro_area_tuples = pyomo.Set(
within=m.stf * m.sit * m.pro,
initialize=tuple(m.proc_area_dict.keys()),
doc='Processes and Sites with area Restriction')
# process input/output
m.pro_input_tuples = pyomo.Set(
within=m.stf * m.sit * m.pro * m.com,
initialize=[(stf, site, process, commodity)
for (stf, site, process) in m.pro_tuples
for (s, pro, commodity) in tuple(m.r_in_dict.keys())
if process == pro and s == stf],
doc='Commodities consumed by process by site,'
'e.g. (2020,Mid,PV,Solar)')
m.pro_output_tuples = pyomo.Set(
within=m.stf * m.sit * m.pro * m.com,
initialize=[(stf, site, process, commodity)
for (stf, site, process) in m.pro_tuples
for (s, pro, commodity) in tuple(m.r_out_dict.keys())
if process == pro and s == stf],
doc='Commodities produced by process by site, e.g. (2020,Mid,PV,Elec)')
# process tuples for maximum gradient feature
m.pro_maxgrad_tuples = pyomo.Set(
within=m.stf * m.sit * m.pro,
initialize=[(stf, sit, pro) for (stf, sit, pro) in m.pro_tuples
if m.process_dict['max-grad'][stf, sit, pro] < 1.0 / dt],
doc='Processes with maximum gradient smaller than timestep length')
# process tuples for partial feature
m.pro_partial_tuples = pyomo.Set(
within=m.stf * m.sit * m.pro,
initialize=[(stf, site, process)
for (stf, site, process) in m.pro_tuples
for (s, pro, _) in tuple(m.r_in_min_fraction_dict.keys())
if process == pro and s == stf],
doc='Processes with partial input')
m.pro_partial_input_tuples = pyomo.Set(
within=m.stf * m.sit * m.pro * m.com,
initialize=[(stf, site, process, commodity)
for (stf, site, process) in m.pro_partial_tuples
for (s, pro,
commodity) in tuple(m.r_in_min_fraction_dict.keys())
if process == pro and s == stf],
doc='Commodities with partial input ratio,'
'e.g. (2020,Mid,Coal PP,Coal)')
m.pro_partial_output_tuples = pyomo.Set(
within=m.stf * m.sit * m.pro * m.com,
initialize=[(stf, site, process, commodity)
for (stf, site, process) in m.pro_partial_tuples
for (s, pro,
commodity) in tuple(m.r_out_min_fraction_dict.keys())
if process == pro and s == stf],
doc='Commodities with partial input ratio, e.g. (Mid,Coal PP,CO2)')
# Variables
# costs
m.costs = pyomo.Var(m.cost_type,
within=pyomo.Reals,
doc='Costs by type (EUR/a)')
# commodity
m.e_co_stock = pyomo.Var(
m.tm,
m.com_tuples,
within=pyomo.NonNegativeReals,
doc='Use of stock commodity source (MW) per timestep')
# process
m.cap_pro_new = pyomo.Var(m.pro_tuples,
within=pyomo.NonNegativeReals,
doc='New process capacity (MW)')
# process capacity as expression object
# (variable if expansion is possible, else static)
m.cap_pro = pyomo.Expression(m.pro_tuples,
rule=def_process_capacity_rule,
doc='total process capacity')
m.tau_pro = pyomo.Var(m.t,
m.pro_tuples,
within=pyomo.NonNegativeReals,
doc='Power flow (MW) through process')
m.e_pro_in = pyomo.Var(
m.tm,
m.pro_input_tuples,
within=pyomo.NonNegativeReals,
doc='Power flow of commodity into process (MW) per timestep')
m.e_pro_out = pyomo.Var(m.tm,
m.pro_output_tuples,
within=pyomo.NonNegativeReals,
doc='Power flow out of process (MW) per timestep')
# Add additional features
# called features are declared in distinct files in features folder
if m.mode['tra']:
if m.mode['dpf']:
m = transmission.add_transmission_dc(m)
else:
m = add_transmission(m)
if m.mode['sto']:
m = add_storage(m)
if m.mode['dsm']:
m = add_dsm(m)
if m.mode['bsp']:
m = add_buy_sell_price(m)
if m.mode['tve']:
m = add_time_variable_efficiency(m)
else:
m.pro_timevar_output_tuples = pyomo.Set(
within=m.stf * m.sit * m.pro * m.com,
doc='empty set needed for (partial) process output')
# Equation declarations
# equation bodies are defined in separate functions, referred to here by
# their name in the "rule" keyword.
# commodity
m.res_vertex = pyomo.Constraint(
m.tm,
m.com_tuples,
rule=res_vertex_rule,
doc='storage + transmission + process + source + buy - sell == demand')
m.res_stock_step = pyomo.Constraint(
m.tm,
m.com_tuples,
rule=res_stock_step_rule,
doc='stock commodity input per step <= commodity.maxperstep')
m.res_stock_total = pyomo.Constraint(
m.com_tuples,
rule=res_stock_total_rule,
doc='total stock commodity input <= commodity.max')
m.res_env_step = pyomo.Constraint(
m.tm,
m.com_tuples,
rule=res_env_step_rule,
doc='environmental output per step <= commodity.maxperstep')
m.res_env_total = pyomo.Constraint(
m.com_tuples,
rule=res_env_total_rule,
doc='total environmental commodity output <= commodity.max')
# process
m.def_process_input = pyomo.Constraint(
m.tm,
m.pro_input_tuples - m.pro_partial_input_tuples,
rule=def_process_input_rule,
doc='process input = process throughput * input ratio')
m.def_process_output = pyomo.Constraint(
m.tm, (m.pro_output_tuples - m.pro_partial_output_tuples -
m.pro_timevar_output_tuples),
rule=def_process_output_rule,
doc='process output = process throughput * output ratio')
m.def_intermittent_supply = pyomo.Constraint(
m.tm,
m.pro_input_tuples,
rule=def_intermittent_supply_rule,
doc='process output = process capacity * supim timeseries')
m.res_process_throughput_by_capacity = pyomo.Constraint(
m.tm,
m.pro_tuples,
rule=res_process_throughput_by_capacity_rule,
doc='process throughput <= total process capacity')
m.res_process_maxgrad_lower = pyomo.Constraint(
m.tm,
m.pro_maxgrad_tuples,
rule=res_process_maxgrad_lower_rule,
doc='throughput may not decrease faster than maximal gradient')
m.res_process_maxgrad_upper = pyomo.Constraint(
m.tm,
m.pro_maxgrad_tuples,
rule=res_process_maxgrad_upper_rule,
doc='throughput may not increase faster than maximal gradient')
m.res_process_capacity = pyomo.Constraint(
m.pro_tuples,
rule=res_process_capacity_rule,
doc='process.cap-lo <= total process capacity <= process.cap-up')
m.res_area = pyomo.Constraint(
m.sit_tuples,
rule=res_area_rule,
doc='used process area <= total process area')
m.res_throughput_by_capacity_min = pyomo.Constraint(
m.tm,
m.pro_partial_tuples,
rule=res_throughput_by_capacity_min_rule,
doc='cap_pro * min-fraction <= tau_pro')
m.def_partial_process_input = pyomo.Constraint(
m.tm,
m.pro_partial_input_tuples,
rule=def_partial_process_input_rule,
doc='e_pro_in = '
' cap_pro * min_fraction * (r - R) / (1 - min_fraction)'
' + tau_pro * (R - min_fraction * r) / (1 - min_fraction)')
m.def_partial_process_output = pyomo.Constraint(
m.tm, (m.pro_partial_output_tuples -
(m.pro_partial_output_tuples & m.pro_timevar_output_tuples)),
rule=def_partial_process_output_rule,
doc='e_pro_out = '
' cap_pro * min_fraction * (r - R) / (1 - min_fraction)'
' + tau_pro * (R - min_fraction * r) / (1 - min_fraction)')
if m.mode['int']:
m.res_global_co2_limit = pyomo.Constraint(
m.stf,
rule=res_global_co2_limit_rule,
doc='total co2 commodity output <= global.prop CO2 limit')
# costs
m.def_costs = pyomo.Constraint(m.cost_type,
rule=def_costs_rule,
doc='main cost function by cost type')
# objective and global constraints
if m.obj.value == 'cost':
if m.mode['int']:
m.res_global_co2_budget = pyomo.Constraint(
rule=res_global_co2_budget_rule,
doc='total co2 commodity output <= global.prop CO2 budget')
else:
m.res_global_co2_limit = pyomo.Constraint(
m.stf,
rule=res_global_co2_limit_rule,
doc='total co2 commodity output <= Global CO2 limit')
m.objective_function = pyomo.Objective(
rule=cost_rule,
sense=pyomo.minimize,
doc='minimize(cost = sum of all cost types)')
elif m.obj.value == 'CO2':
m.res_global_cost_limit = pyomo.Constraint(
rule=res_global_cost_limit_rule,
doc='total costs <= Global cost limit')
m.objective_function = pyomo.Objective(
rule=co2_rule,
sense=pyomo.minimize,
doc='minimize total CO2 emissions')
else:
raise NotImplementedError("Non-implemented objective quantity. Set "
"either 'cost' or 'CO2' as the objective in "
"runme.py!")
if dual:
m.dual = pyomo.Suffix(direction=pyomo.Suffix.IMPORT)
return m
def create_model(data, dt=1, timesteps=None, dual=False):
"""Create a pyomo ConcreteModel urbs object from given input data.
Args:
data: a dict of 6 DataFrames with the keys 'commodity', 'process',
'transmission', 'storage', 'demand' and 'supim'.
dt: timestep duration in hours (default: 1)
timesteps: optional list of timesteps, default: demand timeseries
dual: set True to add dual variables to model (slower); default: False
Returns:
a pyomo ConcreteModel object
"""
# Optional
if not timesteps:
timesteps = data['demand'].index.tolist()
m = pyomo_model_prep(data, timesteps) # preparing pyomo model
m.name = 'urbs'
m.created = datetime.now().strftime('%Y%m%dT%H%M')
m._data = data
# Parameters
# weight = length of year (hours) / length of simulation (hours)
# weight scales costs and emissions from length of simulation to a full
# year, making comparisons among cost types (invest is annualized, fixed
# costs are annual by default, variable costs are scaled by weight) and
# among different simulation durations meaningful.
m.weight = pyomo.Param(
initialize=float(8760) / (len(m.timesteps) * dt),
doc='Pre-factor for variable costs and emissions for an annual result')
# dt = spacing between timesteps. Required for storage equation that
# converts between energy (storage content, e_sto_con) and power (all other
# quantities that start with "e_")
m.dt = pyomo.Param(
initialize=dt,
doc='Time step duration (in hours), default: 1')
# Sets
# ====
# Syntax: m.{name} = Set({domain}, initialize={values})
# where name: set name
# domain: set domain for tuple sets, a cartesian set product
# values: set values, a list or array of element tuples
# generate ordered time step sets
m.t = pyomo.Set(
initialize=m.timesteps,
ordered=True,
doc='Set of timesteps')
# modelled (i.e. excluding init time step for storage) time steps
m.tm = pyomo.Set(
within=m.t,
initialize=m.timesteps[1:],
ordered=True,
doc='Set of modelled timesteps')
# site (e.g. north, middle, south...)
m.sit = pyomo.Set(
initialize=m.commodity.index.get_level_values('Site').unique(),
doc='Set of sites')
# commodity (e.g. solar, wind, coal...)
m.com = pyomo.Set(
initialize=m.commodity.index.get_level_values('Commodity').unique(),
doc='Set of commodities')
# commodity type (i.e. SupIm, Demand, Stock, Env)
m.com_type = pyomo.Set(
initialize=m.commodity.index.get_level_values('Type').unique(),
doc='Set of commodity types')
# process (e.g. Wind turbine, Gas plant, Photovoltaics...)
m.pro = pyomo.Set(
initialize=m.process.index.get_level_values('Process').unique(),
doc='Set of conversion processes')
# tranmission (e.g. hvac, hvdc, pipeline...)
m.tra = pyomo.Set(
initialize=m.transmission.index.get_level_values('Transmission')
.unique(),
doc='Set of transmission technologies')
# storage (e.g. hydrogen, pump storage)
m.sto = pyomo.Set(
initialize=m.storage.index.get_level_values('Storage').unique(),
doc='Set of storage technologies')
# cost_type
m.cost_type = pyomo.Set(
initialize=['Invest', 'Fixed', 'Variable', 'Fuel',
'Environmental'],
doc='Set of cost types (hard-coded)')
# tuple sets
m.com_tuples = pyomo.Set(
within=m.sit*m.com*m.com_type,
initialize=m.commodity.index,
doc='Combinations of defined commodities, e.g. (Mid,Elec,Demand)')
m.pro_tuples = pyomo.Set(
within=m.sit*m.pro,
initialize=m.process.index,
doc='Combinations of possible processes, e.g. (North,Coal plant)')
m.tra_tuples = pyomo.Set(
within=m.sit*m.sit*m.tra*m.com,
initialize=m.transmission.index,
doc='Combinations of possible transmissions, e.g. '
'(South,Mid,hvac,Elec)')
m.sto_tuples = pyomo.Set(
within=m.sit*m.sto*m.com,
initialize=m.storage.index,
doc='Combinations of possible storage by site, e.g. (Mid,Bat,Elec)')
# commodity type subsets
m.com_supim = pyomo.Set(
within=m.com,
initialize=commodity_subset(m.com_tuples, 'SupIm'),
doc='Commodities that have intermittent (timeseries) input')
m.com_stock = pyomo.Set(
within=m.com,
initialize=commodity_subset(m.com_tuples, 'Stock'),
doc='Commodities that can be purchased at some site(s)')
m.com_demand = pyomo.Set(
within=m.com,
initialize=commodity_subset(m.com_tuples, 'Demand'),
doc='Commodities that have a demand (implies timeseries)')
m.com_env = pyomo.Set(
within=m.com,
initialize=commodity_subset(m.com_tuples, 'Env'),
doc='Commodities that (might) have a maximum creation limit')
# process input/output
m.pro_input_tuples = pyomo.Set(
within=m.sit*m.pro*m.com,
initialize=[(site, process, commodity)
for (site, process) in m.pro_tuples
for (pro, commodity) in m.r_in.index
if process == pro],
doc='Commodities consumed by process by site, e.g. (Mid,PV,Solar)')
m.pro_output_tuples = pyomo.Set(
within=m.sit*m.pro*m.com,
initialize=[(site, process, commodity)
for (site, process) in m.pro_tuples
for (pro, commodity) in m.r_out.index
if process == pro],
doc='Commodities produced by process by site, e.g. (Mid,PV,Elec)')
# storage tuples for storages with fixed initial state
m.sto_init_bound_tuples = pyomo.Set(
within=m.sit*m.sto*m.com,
initialize=m.stor_init_bound.index,
doc='storages with fixed initial state')
# storage tuples for storages with given energy to power ratio
m.sto_ep_ratio_tuples = pyomo.Set(
within=m.sit*m.sto*m.com,
initialize=m.sto_ep_ratio.index,
doc='storages with given energy to power ratio')
# Variables
# costs
m.costs = pyomo.Var(
m.cost_type,
within=pyomo.Reals,
doc='Costs by type (EUR/a)')
# commodity
m.e_co_stock = pyomo.Var(
m.tm, m.com_tuples,
within=pyomo.NonNegativeReals,
doc='Use of stock commodity source (MW) per timestep')
# process
m.cap_pro = pyomo.Var(
m.pro_tuples,
within=pyomo.NonNegativeReals,
doc='Total process capacity (MW)')
m.cap_pro_new = pyomo.Var(
m.pro_tuples,
within=pyomo.NonNegativeReals,
doc='New process capacity (MW)')
m.tau_pro = pyomo.Var(
m.t, m.pro_tuples,
within=pyomo.NonNegativeReals,
doc='Power flow (MW) through process')
m.e_pro_in = pyomo.Var(
m.tm, m.pro_tuples, m.com,
within=pyomo.NonNegativeReals,
doc='Power flow of commodity into process (MW) per timestep')
m.e_pro_out = pyomo.Var(
m.tm, m.pro_tuples, m.com,
within=pyomo.NonNegativeReals,
doc='Power flow out of process (MW) per timestep')
# transmission
m.cap_tra = pyomo.Var(
m.tra_tuples,
within=pyomo.NonNegativeReals,
doc='Total transmission capacity (MW)')
m.cap_tra_new = pyomo.Var(
m.tra_tuples,
within=pyomo.NonNegativeReals,
doc='New transmission capacity (MW)')
m.e_tra_in = pyomo.Var(
m.tm, m.tra_tuples,
within=pyomo.NonNegativeReals,
doc='Power flow into transmission line (MW) per timestep')
m.e_tra_out = pyomo.Var(
m.tm, m.tra_tuples,
within=pyomo.NonNegativeReals,
doc='Power flow out of transmission line (MW) per timestep')
# storage
m.cap_sto_c = pyomo.Var(
m.sto_tuples,
within=pyomo.NonNegativeReals,
doc='Total storage size (MWh)')
m.cap_sto_c_new = pyomo.Var(
m.sto_tuples,
within=pyomo.NonNegativeReals,
doc='New storage size (MWh)')
m.cap_sto_p = pyomo.Var(
m.sto_tuples,
within=pyomo.NonNegativeReals,
doc='Total storage power (MW)')
m.cap_sto_p_new = pyomo.Var(
m.sto_tuples,
within=pyomo.NonNegativeReals,
doc='New storage power (MW)')
m.e_sto_in = pyomo.Var(
m.tm, m.sto_tuples,
within=pyomo.NonNegativeReals,
doc='Power flow into storage (MW) per timestep')
m.e_sto_out = pyomo.Var(
m.tm, m.sto_tuples,
within=pyomo.NonNegativeReals,
doc='Power flow out of storage (MW) per timestep')
m.e_sto_con = pyomo.Var(
m.t, m.sto_tuples,
within=pyomo.NonNegativeReals,
doc='Energy content of storage (MWh) in timestep')
# Equation declarations
# equation bodies are defined in separate functions, referred to here by
# their name in the "rule" keyword.
# commodity
m.res_vertex = pyomo.Constraint(
m.tm, m.com_tuples,
rule=res_vertex_rule,
doc='storage + transmission + process + source == demand')
# process
m.def_process_capacity = pyomo.Constraint(
m.pro_tuples,
rule=def_process_capacity_rule,
doc='total process capacity = inst-cap + new capacity')
m.def_process_input = pyomo.Constraint(
m.tm, m.pro_input_tuples,
rule=def_process_input_rule,
doc='process input = process throughput * input ratio')
m.def_process_output = pyomo.Constraint(
m.tm, m.pro_output_tuples,
rule=def_process_output_rule,
doc='process output = process throughput * output ratio')
m.def_intermittent_supply = pyomo.Constraint(
m.tm, m.pro_input_tuples,
rule=def_intermittent_supply_rule,
doc='process output = process capacity * supim timeseries')
m.res_process_throughput_by_capacity = pyomo.Constraint(
m.tm, m.pro_tuples,
rule=res_process_throughput_by_capacity_rule,
doc='process throughput <= total process capacity')
m.res_process_capacity = pyomo.Constraint(
m.pro_tuples,
rule=res_process_capacity_rule,
doc='process.cap-lo <= total process capacity <= process.cap-up')
# transmission
m.def_transmission_capacity = pyomo.Constraint(
m.tra_tuples,
rule=def_transmission_capacity_rule,
doc='total transmission capacity = inst-cap + new capacity')
m.def_transmission_output = pyomo.Constraint(
m.tm, m.tra_tuples,
rule=def_transmission_output_rule,
doc='transmission output = transmission input * efficiency')
m.res_transmission_input_by_capacity = pyomo.Constraint(
m.tm, m.tra_tuples,
rule=res_transmission_input_by_capacity_rule,
doc='transmission input <= total transmission capacity')
m.res_transmission_capacity = pyomo.Constraint(
m.tra_tuples,
rule=res_transmission_capacity_rule,
doc='transmission.cap-lo <= total transmission capacity <= '
'transmission.cap-up')
m.res_transmission_symmetry = pyomo.Constraint(
m.tra_tuples,
rule=res_transmission_symmetry_rule,
doc='total transmission capacity must be symmetric in both directions')
# storage
m.def_storage_state = pyomo.Constraint(
m.tm, m.sto_tuples,
rule=def_storage_state_rule,
doc='storage[t] = (1 - sd) * storage[t-1] + in * eff_i - out / eff_o')
m.def_storage_power = pyomo.Constraint(
m.sto_tuples,
rule=def_storage_power_rule,
doc='storage power = inst-cap + new power')
m.def_storage_capacity = pyomo.Constraint(
m.sto_tuples,
rule=def_storage_capacity_rule,
doc='storage capacity = inst-cap + new capacity')
m.res_storage_input_by_power = pyomo.Constraint(
m.tm, m.sto_tuples,
rule=res_storage_input_by_power_rule,
doc='storage input <= storage power')
m.res_storage_output_by_power = pyomo.Constraint(
m.tm, m.sto_tuples,
rule=res_storage_output_by_power_rule,
doc='storage output <= storage power')
m.res_storage_state_by_capacity = pyomo.Constraint(
m.t, m.sto_tuples,
rule=res_storage_state_by_capacity_rule,
doc='storage content <= storage capacity')
m.res_storage_power = pyomo.Constraint(
m.sto_tuples,
rule=res_storage_power_rule,
doc='storage.cap-lo-p <= storage power <= storage.cap-up-p')
m.res_storage_capacity = pyomo.Constraint(
m.sto_tuples,
rule=res_storage_capacity_rule,
doc='storage.cap-lo-c <= storage capacity <= storage.cap-up-c')
m.res_initial_and_final_storage_state = pyomo.Constraint(
m.t, m.sto_init_bound_tuples,
rule=res_initial_and_final_storage_state_rule,
doc='storage content initial == and final >= storage.init * capacity')
m.res_initial_and_final_storage_state_var = pyomo.Constraint(
m.t, m.sto_tuples - m.sto_init_bound_tuples,
rule=res_initial_and_final_storage_state_var_rule,
doc='storage content initial <= final, both variable')
m.def_storage_energy_power_ratio = pyomo.Constraint(
m.sto_ep_ratio_tuples,
rule=def_storage_energy_power_ratio_rule,
doc='storage capacity = storage power * storage E2P ratio')
# costs
m.def_costs = pyomo.Constraint(
m.cost_type,
rule=def_costs_rule,
doc='main cost function by cost type')
m.obj = pyomo.Objective(
rule=obj_rule,
sense=pyomo.minimize,
doc='minimize(cost = sum of all cost types)')
# global
m.res_global_co2_limit = pyomo.Constraint(
rule=res_global_co2_limit_rule,
doc='total co2 commodity output <= Global CO2 limit')
if dual:
m.dual = pyomo.Suffix(direction=pyomo.Suffix.IMPORT)
return m
def create_model(ems_local):
""" create one optimization instance and parameterize it with the input data in ems model
Args:
- ems_local: ems model which has been parameterized
Return:
- m: optimization model instance created according to ems model
"""
# record the time
t0 = tm.time()
# get all the data from the external file
# ems_local = ems_loc(initialize=True, path='C:/Users/ge57vam/emsflex/opentumflex/ems01_ems.txt')
devices = ems_local['devices']
# read data from excel file
# print('Data Read. time: ' + "{:.1f}".format(tm.time() - t0) + ' s\n')
# print('Prepare Data ...\n')
t = tm.time()
time_interval = ems_local['time_data'][
't_inval'] # x minutes for one time step
# write in the time series from the data
df_time_series = ems_local['fcst']
time_series = pd.DataFrame.from_dict(df_time_series)
# time = time_series.index.values
# print('Data Prepared. time: ' + "{:.1f}".format(tm.time() - t0) + ' s\n')
# system
# get the initial time step
# time_step_initial = parameter.loc['System']['value']
time_step_initial = ems_local['time_data']['isteps']
# time_step_end = int(60 / time_interval * 24)
time_step_end = ems_local['time_data']['nsteps']
timesteps = np.arange(time_step_initial, time_step_end)
# timestep_1 = timesteps[0]
# timesteps = timesteps_all[time_step_initial:time_step_end]
t_dn = 4
# 6*time_step_end/96
t_up = 4
# 6*time_step_end/96
timesteps_dn = timesteps[time_step_initial + 1:time_step_end - t_dn]
timesteps_up = timesteps[time_step_initial + 1:time_step_end - t_up]
# 15 min for every timestep/ timestep by one hour
# create the concrete model
p2e = time_interval / 60
# create the model object m
m = pyen.ConcreteModel()
# create the parameter
# print('Define Model ...\n')
m.t = pyen.Set(ordered=True, initialize=timesteps)
m.t_DN = pyen.Set(ordered=True, initialize=timesteps_dn)
m.t_UP = pyen.Set(ordered=True, initialize=timesteps_up)
# heat_storage
sto_param = devices['sto']
m.sto_max_cont = pyen.Param(initialize=sto_param['stocap'])
m.SOC_init = pyen.Param(initialize=sto_param['initSOC'])
m.temp_min = pyen.Param(initialize=sto_param['mintemp'])
m.temp_max = pyen.Param(initialize=sto_param['maxtemp'])
# battery
bat_param = devices['bat']
m.bat_cont_max = pyen.Param(initialize=bat_param['stocap'])
m.bat_SOC_init = pyen.Param(initialize=bat_param['initSOC'])
m.bat_power_max = pyen.Param(initialize=bat_param['maxpow'])
m.bat_eta = pyen.Param(initialize=bat_param['eta'])
# heat pump
hp_param = devices['hp']
hp_elec_cap = pd.DataFrame.from_dict(hp_param['powmap'])
hp_cop = pd.DataFrame.from_dict(hp_param['COP'])
hp_supply_temp = hp_param['supply_temp']
m.hp_ther_pow = pyen.Param(m.t,
initialize=1,
mutable=True,
within=pyen.NonNegativeReals)
m.hp_COP = pyen.Param(m.t,
initialize=1,
mutable=True,
within=pyen.NonNegativeReals)
m.hp_elec_pow = pyen.Param(m.t,
initialize=1,
mutable=True,
within=pyen.NonNegativeReals)
m.T_DN = pyen.Param(initialize=t_dn, mutable=True)
m.T_UP = pyen.Param(initialize=t_up, mutable=True)
m.hp_themInertia = pyen.Param(initialize=hp_param['thermInertia'])
m.hp_minTemp = pyen.Param(initialize=hp_param['minTemp'])
m.hp_maxTemp = pyen.Param(initialize=hp_param['maxTemp'])
m.hp_heatgain = pyen.Param(initialize=hp_param['heatgain'])
# elec_vehicle
ev_param = devices['ev']
ev_aval = ev_param['aval']
m.ev_min_pow = pyen.Param(initialize=ev_param['minpow'])
m.ev_max_pow = pyen.Param(initialize=ev_param['maxpow'])
m.ev_sto_cap = pyen.Param(initialize=ev_param['stocap'])
m.ev_eta = pyen.Param(initialize=ev_param['eta'])
m.ev_aval = pyen.Param(m.t, initialize=1, mutable=True)
m.ev_charg_amount = m.ev_sto_cap * (ev_param['endSOC'][-1] -
ev_param['initSOC'][0]) / 100
ev_soc_init = ev_param['initSOC']
ev_soc_end = ev_param['endSOC']
ev_init_soc_check = ev_param['init_soc_check']
ev_end_soc_check = ev_param['end_soc_check']
# boilder
boil_param = devices['boiler']
m.boiler_max_cap = pyen.Param(initialize=boil_param['maxpow'])
m.boiler_eff = pyen.Param(initialize=boil_param['eta'])
# CHP
chp_param = devices['chp']
m.chp_elec_effic = pyen.Param(m.t, initialize=chp_param['eta'][0])
m.chp_ther_effic = pyen.Param(m.t, initialize=chp_param['eta'][1])
m.chp_elec_run = pyen.Param(m.t, initialize=chp_param['maxpow'])
m.chp_heat_run = pyen.Param(m.t, initialize=0, mutable=True)
m.chp_gas_run = pyen.Param(m.t, initialize=0, mutable=True)
# solar
pv_param = devices['pv']
# m.pv_effic = pyen.Param(initialize=pv_param['eta'])
m.pv_peak_power = pyen.Param(initialize=pv_param['maxpow'])
m.solar = pyen.Param(m.t, initialize=1, mutable=True)
# for t in m.t_UP:
# m.t_dn[t] = t_dn
# m.t_up[t] = t_dn
# price
m.ele_price_in, m.ele_price_out, m.gas_price = (pyen.Param(m.t,
initialize=1,
mutable=True)
for i in range(3))
# lastprofil
m.lastprofil_heat, m.lastprofil_elec = (pyen.Param(m.t,
initialize=1,
mutable=True)
for i in range(2))
for t in m.t:
# weather data
m.ele_price_in[t] = time_series.loc[t]['ele_price_in']
m.gas_price[t] = time_series.loc[t]['gas_price']
m.ele_price_out[t] = time_series.loc[t]['ele_price_out']
m.lastprofil_heat[t] = time_series.loc[t]['load_heat']
m.lastprofil_elec[t] = time_series.loc[t]['load_elec']
m.solar[t] = time_series.loc[t]['solar_power']
# fill the ev availability
m.ev_aval[t] = ev_aval[t]
# calculate the spline function for thermal power of heat pump
spl_elec_pow = UnivariateSpline(
list(map(float, hp_elec_cap.columns.values)),
list(hp_elec_cap.loc[hp_supply_temp, :]))
m.hp_elec_pow[t] = spl_elec_pow(time_series.loc[t]['temperature'] +
273.15).item(0)
# calculate the spline function for COP of heat pump
spl_cop = UnivariateSpline(list(map(float, hp_cop.columns.values)),
list(hp_cop.loc[hp_supply_temp, :]))
m.hp_COP[t] = spl_cop(time_series.loc[t]['temperature'] +
273.15).item(0)
m.hp_ther_pow[t] = m.hp_elec_pow[t] * m.hp_COP[t]
# calculate the chp electric and thermal power when it's running
m.chp_heat_run[
t] = m.chp_elec_run[t] / m.chp_elec_effic[t] * m.chp_ther_effic[t]
m.chp_gas_run[t] = m.chp_elec_run[t] / m.chp_elec_effic[t]
# m.ele_price = ele_price
# Variables
m.hp_run = pyen.Var(m.t,
within=pyen.Boolean,
doc='operation of the heat pump')
m.CHP_run = pyen.Var(m.t, within=pyen.Boolean, doc='operation of the CHP')
m.ev_power = pyen.Var(m.t,
within=pyen.NonNegativeReals,
bounds=(ev_param['minpow'], ev_param['maxpow']),
doc='power of the EV')
m.boiler_cap, m.PV_cap, m.elec_import, m.elec_export, m.bat_cont, m.sto_e_cont, m.bat_pow_pos, m.bat_pow_neg, \
m.ev_cont, m.ev_var_pow, m.soc_diff, m.roomtemp = (pyen.Var(m.t, within=pyen.NonNegativeReals) for i in range(12))
m.sto_e_pow, m.costs, m.heatextra = (pyen.Var(m.t, within=pyen.Reals)
for i in range(3))
# Constrains
# heat_storage
def sto_e_cont_def_rule(m, t):
if t > m.t[1]:
return m.sto_e_cont[t] == m.sto_e_cont[t -
1] + m.sto_e_pow[t] * p2e
else:
return m.sto_e_cont[
t] == m.sto_max_cont * m.SOC_init / 100 + m.sto_e_pow[t] * p2e
m.sto_e_cont_def = pyen.Constraint(m.t,
rule=sto_e_cont_def_rule,
doc='heat_storage_balance')
def heat_balance_rule(m, t):
return m.boiler_cap[t] + m.CHP_run[t] * m.chp_heat_run[t] + \
m.hp_run[t] * m.hp_ther_pow[t] - m.lastprofil_heat[t] - m.sto_e_pow[t] == 0
m.heat_power_balance = pyen.Constraint(m.t,
rule=heat_balance_rule,
doc='heat_storage_balance')
# the room in the building
# def heat_room_rule(m, t):
# if t > m.t[1]:
# return m.roomtemp[t] == m.roomtemp[t - 1] + (m.heatextra[t] + m.hp_heatgain) / m.hp_themInertia
# else:
# return m.roomtemp[t] == 23
#
# m.heat_room_balance = pyen.Constraint(m.t, rule=heat_room_rule, doc='heat_room_balance')
#
# def heat_room_maxtemp_rule(m, t):
# return m.roomtemp[t] <= m.hp_maxTemp
#
# m.heat_room_maxtemp = pyen.Constraint(m.t, rule=heat_room_maxtemp_rule)
#
# def heat_room_mintemp_rule(m, t):
# return m.roomtemp[t] >= m.hp_minTemp
#
# m.heat_room_mintemp = pyen.Constraint(m.t, rule=heat_room_mintemp_rule)
#
# def heat_room_end_rule(m, t):
# if t == m.t[-1]:
# return m.roomtemp[t] == 23
# else:
# return Constraint.Skip
#
# m.heat_room_end = pyen.Constraint(m.t, rule=heat_room_end_rule)
# battery
def battery_e_cont_def_rule(m, t):
if t > m.t[1]:
return m.bat_cont[t] == m.bat_cont[
t - 1] + (m.bat_pow_pos[t] * m.bat_eta -
m.bat_pow_neg[t] / m.bat_eta) * p2e
else:
return m.bat_cont[t] == m.bat_cont_max * m.bat_SOC_init / 100 + (
m.bat_pow_pos[t] * m.bat_eta -
m.bat_pow_neg[t] / m.bat_eta) * p2e
m.bat_e_cont_def = pyen.Constraint(m.t,
rule=battery_e_cont_def_rule,
doc='battery_balance')
def elec_balance_rule(m, t):
return m.elec_import[t] + m.CHP_run[t] * m.chp_elec_run[t] + m.PV_cap[t] * m.solar[t] - \
m.elec_export[t] - m.hp_run[t] * m.hp_elec_pow[t] - m.lastprofil_elec[t] - \
(m.bat_pow_pos[t] - m.bat_pow_neg[t]) - m.ev_power[t] == 0
m.elec_power_balance = pyen.Constraint(m.t,
rule=elec_balance_rule,
doc='elec_balance')
def cost_sum_rule(m, t):
return m.costs[t] == p2e * (
m.boiler_cap[t] / m.boiler_eff * m.gas_price[t] +
m.CHP_run[t] * m.chp_gas_run[t] * m.gas_price[t] +
m.elec_import[t] * m.ele_price_in[t] -
m.elec_export[t] * m.ele_price_out[t]) + m.soc_diff[t] * 1000
m.cost_sum = pyen.Constraint(m.t, rule=cost_sum_rule)
# ev battery balance
def ev_cont_def_rule(m, t):
if t > m.t[1]:
return m.ev_cont[t] == m.ev_cont[
t - 1] + m.ev_power[t] * p2e * m.ev_eta - m.ev_var_pow[t]
else:
return m.ev_cont[t] == m.ev_sto_cap * ev_soc_init[
0] / 100 + m.ev_power[t] * p2e * m.ev_eta
m.ev_cont_def = pyen.Constraint(m.t,
rule=ev_cont_def_rule,
doc='EV_balance')
def EV_end_soc_rule(m, t):
return m.ev_cont[
t] >= m.ev_sto_cap * ev_end_soc_check[t] / 100 - m.soc_diff[t]
m.EV_end_soc_def = pyen.Constraint(m.t, rule=EV_end_soc_rule)
def EV_init_soc_rule(m, t):
return m.ev_cont[t] <= m.ev_sto_cap * ev_init_soc_check[t] / 100
m.EV_init_soc_def = pyen.Constraint(m.t, rule=EV_init_soc_rule)
def EV_aval_rule(m, t):
return m.ev_power[t] <= m.ev_aval[t] * m.ev_max_pow
m.EV_aval_def = pyen.Constraint(m.t, rule=EV_aval_rule)
# hp
def hp_min_still_t_rule(m, t):
return (m.hp_run[t - 1] - m.hp_run[t]) * m.T_DN <= m.T_DN - (
m.hp_run[t] + m.hp_run[t + 1] + m.hp_run[t + 2] + m.hp_run[t + 3])
# m.hp_min_still_t_def = pyen.Constraint(m.t_DN, rule=hp_min_still_t_rule)
def hp_min_lauf_t_rule(m, t):
return (m.hp_run[t] - m.hp_run[t - 1]) * m.T_UP <= m.hp_run[t] + m.hp_run[t + 1] \
+ m.hp_run[t + 2] + m.hp_run[t + 3]
# m.hp_min_lauf_t_def = pyen.Constraint(m.t_UP, rule=hp_min_lauf_t_rule)
def chp_min_still_t_rule(m, t):
return (m.CHP_run[t - 1] - m.CHP_run[t]) * m.T_DN <= m.T_DN - (
m.CHP_run[t] + m.CHP_run[t + 1])
# m.chp_min_still_t_def = pyen.Constraint(m.t_DN, rule=chp_min_still_t_rule)
def chp_min_lauf_t_rule(m, t):
return (m.CHP_run[t] -
m.CHP_run[t - 1]) * m.T_UP <= m.CHP_run[t] + m.CHP_run[t + 1]
# m.chp_min_lauf_t_def = pyen.Constraint(m.t_UP, rule=chp_min_lauf_t_rule)
# boiler
def boiler_max_cap_rule(m, t):
return m.boiler_cap[t] <= m.boiler_max_cap
m.boiler_max_cap_def = pyen.Constraint(m.t, rule=boiler_max_cap_rule)
# PV
def pv_max_cap_rule(m, t):
return m.PV_cap[t] <= m.pv_peak_power
m.pv_max_cap_def = pyen.Constraint(m.t, rule=pv_max_cap_rule)
# elec_import
def elec_import_rule(m, t):
return m.elec_import[t] <= 50 * 5000
m.elec_import_def = pyen.Constraint(m.t, rule=elec_import_rule)
# elec_export
def elec_export_rule(m, t):
return m.elec_export[t] <= 50 * 5000
m.elec_export_def = pyen.Constraint(m.t, rule=elec_export_rule)
# storage
# storage content
if m.sto_max_cont > 0:
def sto_e_cont_min_rule(m, t):
return m.sto_e_cont[t] / m.sto_max_cont >= 0.1
m.sto_e_cont_min = pyen.Constraint(m.t, rule=sto_e_cont_min_rule)
def sto_e_cont_max_rule(m, t):
return m.sto_e_cont[t] / m.sto_max_cont <= 0.9
m.sto_e_cont_max = pyen.Constraint(m.t, rule=sto_e_cont_max_rule)
if m.bat_cont_max > 0:
def bat_e_cont_min_rule(m, t):
return m.bat_cont[t] / m.bat_cont_max >= 0.1
m.bat_e_cont_min = pyen.Constraint(m.t, rule=bat_e_cont_min_rule)
def bat_e_cont_max_rule(m, t):
return m.bat_cont[t] / m.bat_cont_max <= 0.9
m.bat_e_cont_max = pyen.Constraint(m.t, rule=bat_e_cont_max_rule)
# storage power
def sto_e_max_pow_rule_1(m, t):
return m.sto_e_pow[t] <= m.sto_max_cont
m.sto_e_pow_max_1 = pyen.Constraint(m.t, rule=sto_e_max_pow_rule_1)
def sto_e_max_pow_rule_2(m, t):
return m.sto_e_pow[t] >= -m.sto_max_cont
m.sto_e_pow_max_2 = pyen.Constraint(m.t, rule=sto_e_max_pow_rule_2)
def bat_e_max_pow_rule_1(m, t):
return m.bat_pow_pos[t] <= min(m.bat_power_max, m.bat_cont_max)
m.bat_e_pow_max_1 = pyen.Constraint(m.t, rule=bat_e_max_pow_rule_1)
def bat_e_max_pow_rule_2(m, t):
return m.bat_pow_neg[t] <= min(m.bat_power_max, m.bat_cont_max)
m.bat_e_pow_max_2 = pyen.Constraint(m.t, rule=bat_e_max_pow_rule_2)
# end state of storage and battery
m.sto_e_cont_end = pyen.Constraint(
expr=(m.sto_e_cont[m.t[-1]] >= 0.5 * m.sto_max_cont))
m.bat_e_cont_end = pyen.Constraint(
expr=(m.bat_cont[m.t[-1]] >= 0.5 * m.bat_cont_max))
def obj_rule(m):
# Return sum of total costs over all cost types.
# Simply calculates the sum of m.costs over all m.cost_types.
return pyen.summation(m.costs)
m.obj = pyen.Objective(sense=pyen.minimize,
rule=obj_rule,
doc='Sum costs by cost type')
return m
def lp_unit_factors(ranges, solver_name, solver_io, solver_tolerance):
'''Solve an auxiliary LP to find optimal scaling factors for given unit ranges:
Given a set of units {u1, u2, ..., un}
and the range of absolute values of each unit
{ u1 -> [l1, r1], ..., un -> [ln, rn]}
we want to find scaling factors f1, ..., fn that minimize
max(fi*ri)/min(fj*rj)
A difficulty arises because each unit is a fraction of two base units: ui = bj/bk
and we need to retain consistency between scaling factors.
Thus we optimize the scaling factors Fj of base units bj and compute factors of "composite" units, i.e.
ui = bj/bk --> fi = Fj/Fk'''
def bound_rule(model, num1, den1, v1, num2, den2, v2):
'''Link r, the log of the largest gap, to the scaling factor variables.'''
def g(acc):
return model.x[acc] if acc != 'const' else 0
return g(num1) - g(den1) + v1 - g(num2) + g(den2) - v2 <= model.r
def lower_limits_rule(model, num1, den1, v):
'''Forbid that unit num1/den1 is scaled too low.'''
def g(acc):
return model.x[acc] if acc != 'const' else 0
return g(num1) - g(den1) >= v
model = po.ConcreteModel()
'''
variables
(a) We create one variable for the log of the scaling factor of each unit
(b) And one variable r to be minimized
'''
unitvars = [unit for unit in filter(
lambda u: u != 'const',
list(set(
list(map(lambda r: r['num'], ranges)) +
list(map(lambda r: r['den'], ranges))
)))
]
model.x = po.Var(unitvars, domain=po.Reals)
model.r = po.Var(domain=po.Reals)
'''
set objective to minimize r
'''
model.cost = po.Objective(expr = model.r)
'''
Constraints:
limit si - sj + (u_hi){i/j} - sk + sl - (u_lo){k/l} <= r
for all pairs of units u{i/j}, u{k/l}
to find max_{{i/j}, {k/l} \in units}(si*sl/sj*sk (u_hi){i/j} / (u_lo){k/l})
'''
ranges_wo_const = [rng for rng in ranges if rng['num'] != 'const' or rng['den'] != 'const']
boundvals = [
(r1['num'], r1['den'], math.log(r1['max'], 2), r2['num'], r2['den'], math.log(r2['min'], 2))
for r1 in ranges for r2 in ranges
]
model.bounds = po.Constraint(boundvals, rule=bound_rule)
solver = SolverFactory(solver_name, solver_io=solver_io)
solver.solve(model)
temp_facs = {k: 2**model.x[k]() for k in unitvars}
maxs = [r['max'] * temp_facs.get(r['num'], 1) / temp_facs.get(r['den'], 1) for r in ranges]
mins = [r['min'] * temp_facs.get(r['num'], 1) / temp_facs.get(r['den'], 1) for r in ranges]
best_range = max(maxs)/min(mins)
print('best range: {}'.format(best_range))
'''
ensure that absolute values in model are not scaled below a certain threshold.
this generally limits the objective function -> need to find good tradeoff.
Practical Guidelines for Solving Difficult Linear Programs suggests we should ensure that user input consists of values larger than the solver tolerances tol, thus limit values to scaling_tolerance_threshold*tol. Or center the values around 0 if this gives an even higher threshold.
note: our coefficient rounding below may lead to values 2 times smaller than the set limit, thus limit by 2*scaling_tolerance_threshold*tol
'''
lower_limit = 10*solver_tolerance
print('setting limit {}'.format(lower_limit))
violating_mins = set()
while True:
changed = False
factors = {k: 2**model.x[k]() for k in unitvars}
for rng in ranges_wo_const:
num = factors[rng['num']] if rng['num'] != 'const' else 1
den = factors[rng['den']] if rng['den'] != 'const' else 1
if rng['min']*num/den < solver_tolerance:
print('violating {}/{}: {} -> add constr'.format(rng['num'], rng['den'], rng['min']*num/den))
violating_mins.add((rng['num'], rng['den'], math.log(lower_limit/rng['min'], 2)))
changed = True
if not changed:
break
if not model.component('lower_limits') is None:
model.del_component(model.lower_limits)
model.del_component(model.lower_limits_index)
model.add_component('lower_limits', po.Constraint(list(violating_mins), rule=lower_limits_rule))
solver.solve(model)
'''
we want all factors to be an exponent of 2 in order not to tamper with precision of user values (c.f. tomlin - on scaling linear programming problems)
we achieve this by rounding the optimal values we just computed to integers before exponentiating them
'''
facs = {k: 2**math.floor(model.x[k]()) for k in unitvars}
return facs
def create_model(vertex, edge, params={}, timesteps=[]):
"""return a DHMIN model instance from nodes and edges DataFrame
Args:
vertex: DataFrame of vertex with index and attributes
edges: DataFrame of edges with (Vertex1, Vertex2) MultiIndex and attributes
params: dict of cost and technical parameters
timesteps: list of timestep tuples (duration, scaling factor)
Returns:
m: a coopr.pyomo ConcreteModel object
Usage:
see rundh.py
The optional argument params can be used to specify any of the
technical and cost parameters.
The optional argument timesteps is given, DHMIN is run in multi-
seasonal mode that includes a simplified time model. Each (t,p)
tuple encodes a time interval of length (1 hour)*t and relative
peak power requirement (peak)*p of all consumers. Note that sum(t)
must be equal to 8760. The inequalities 0 <= t <= 8760 and 0 <= p <= 1
are to be respected.
"""
m = pyomo.ConcreteModel()
m.name = 'DHMIN'
# DATA PREPARATION
tech_parameters = {
'c_fix': 600, # (€/m) fixed pipe investment
'c_var': 0.015, # (€/kW/m) variable pipe investment
'c_om': 5, # (€/m) operation & maintenance
'r_heat': 0.07, # (€/kWh) retail price for heat
'annuity': anf(40, 0.06), # (%) annuity factor (years, interest)
'thermal_loss_fix': 20e-3, # (kW/m) fixed thermal losses
'thermal_loss_var': 1e-7, # (kW/kW/m) variable thermal losses
'concurrence': 1, # (%) concurrence effect
}
# Entity edge contains column 'Edge' as index. This model (in contrast to
# the old GAMS version) does not use the 'Edge' ID on its own, so remove the
# edge ID from the index ('Edge', 'Vertex1', 'Vertex2')
edges = edge.reset_index('Edge')
# replace default parameter values with user-defined ones, if specified
tech_parameters.update(params)
# make edges symmetric by duplicating each row (i,j) to (j,i)
edges_tmp = edges
edges_tmp.index.names = ['Vertex2', 'Vertex1']
edges_tmp = edges_tmp.reorder_levels(['Vertex1', 'Vertex2'])
edges = edges_tmp.append(edges, verify_integrity=True)
del edges_tmp
# derive list of neighbours for each vertex
m.neighbours = {}
for (i, j) in edges.index:
m.neighbours.setdefault(i, [])
m.neighbours[i].append(j)
#
m.vertices = vertex.copy()
m.edges = edges.copy()
cost_types = [
'network', # pipe construction, maintenance
'heat', # heating plants, operation
'revenue', # sold heat
]
# derive subset of source vertices, i.e. those with column 'init' set to 1
source_vertex = vertex[vertex.init == 1].index
# timestep preparation
if timesteps:
# extend timesteps with (name, duration, scaling factor) tuples and
# add a near-zero (here: 1 hour) legnth, nominal power timestep 'Pmax'
timesteps = [('t{}'.format(t[0]), t[0], t[1]) for t in timesteps]
timesteps.append(('Pmax', 1 , 1))
# now get a list of all source nodes
# for each source, add a non-availability timestep ('v0', 1, 1)
# and set availability matrix so that 'v0' is off in that timestep
availability = np.ones((len(timesteps) + len(source_vertex),
len(source_vertex)),
dtype=np.int)
for i, v0 in enumerate(source_vertex):
availability[len(timesteps), i] = 0
timesteps.append(('v{}'.format(v0), 1, 1))
else:
# no timesteps: create single dummy timestep with 100% availability
timesteps = [('t0', 1, 1)]
availability = np.ones((1,
len(source_vertex)),
dtype=np.int)
# MODEL
# Sets
m.vertex = pyomo.Set(initialize=vertex.index)
m.edge = pyomo.Set(within=m.vertex*m.vertex, initialize=edges.index)
m.cost_types = pyomo.Set(initialize=cost_types)
m.tech_params = pyomo.Set(initialize=tech_parameters.keys())
m.timesteps = pyomo.Set(initialize=[t[0] for t in timesteps])
m.source_vertex = pyomo.Set(initialize=source_vertex)
# Parameters
m.tech_parameters = pyomo.Param(m.tech_params, initialize=tech_parameters)
# derive delta and eta from edge attributes
m.delta = pyomo.Param(m.edge, initialize=dict(
edges['peak']
* edges['cnct_quota']
* tech_parameters['concurrence'] +
edges['length']
* tech_parameters['thermal_loss_fix']
))
m.eta = pyomo.Param(m.edge, initialize=dict(
1 - (edges['length']
* tech_parameters['thermal_loss_var'])
))
# cost coefficients for objective function
# k_fix: power-independent investment and operation & maintenance costs for
# pipes (EUR/a)
m.k_fix = pyomo.Param(m.edge, initialize=dict(
edges['length']
* 0.5 # x and Pmax are forced in both directions (i,j),(j,i)
* tech_parameters['c_fix']
* tech_parameters['annuity']
* (1 - edges['pipe_exist']) +
edges['length']
* 0.5 # x and Pmax are forced in both directions (i,j),(j,i)
* tech_parameters['c_om']
))
# k_var: power-dependent pipe investment costs (EUR/kW/a)
m.k_var = pyomo.Param(m.edge, initialize=dict(
edges['length']
* 0.5 # x and Pmax are forced in both directions (i,j),(j,i)
* tech_parameters['c_var']
* tech_parameters['annuity']
* (1- edges['pipe_exist'])
))
# k_heat: costs for heat generation (EUR/h)
# as the source-term for power flow is lowered by concurrence effect (cf.
# m.delta), for conversion to energy integral, it must be removed again
m.k_heat = pyomo.Param(m.vertex, initialize=dict(
vertex['cost_heat']
/ tech_parameters['concurrence']
))
# r_heat: revenue for heat delivery (EUR/h)
#
m.r_heat = pyomo.Param(m.edge, initialize=dict(
edges['peak']
* 0.5 # x and Pmax are forced in both directions (i,j),(j,i)
* edges['cnct_quota']
* tech_parameters['r_heat']
))
m.availability = pyomo.Param(m.source_vertex, m.timesteps, initialize={
(s,t[0]): availability[x,y]
for y,s in enumerate(source_vertex)
for x,t in enumerate(timesteps)
})
m.dt = pyomo.Param(m.timesteps, initialize={t[0]:t[1] for t in timesteps})
m.scaling_factor = pyomo.Param(m.timesteps, initialize={t[0]:t[2] for t in timesteps})
# Variables
m.costs = pyomo.Var(m.cost_types)
m.x = pyomo.Var(m.edge, within=pyomo.Binary)
m.Pmax = pyomo.Var(m.edge, within=pyomo.NonNegativeReals)
m.Pin = pyomo.Var(m.edge, m.timesteps, within=pyomo.NonNegativeReals)
m.Pot = pyomo.Var(m.edge, m.timesteps, within=pyomo.NonNegativeReals)
m.Q = pyomo.Var(m.vertex, m.timesteps, within=pyomo.NonNegativeReals)
m.y = pyomo.Var(m.edge, m.timesteps, within=pyomo.Binary)
m.energy_conservation = pyomo.Constraint(
m.vertex, m.timesteps,
doc='Power flow is conserved in vertex',
rule=energy_conservation_rule)
m.demand_satisfaction = pyomo.Constraint(
m.edge, m.timesteps,
doc='Peak demand (delta) must be satisfied in edge, if pipe is built',
rule=demand_satisfaction_rule)
m.pipe_capacity = pyomo.Constraint(
m.edge, m.timesteps,
doc='Power flow is smaller than pipe capacity Pmax',
rule=pipe_capacity_rule)
m.pipe_usage = pyomo.Constraint(
m.edge, m.timesteps,
doc='Power flow through pipe=0 if y[i,j,t]=0',
rule=pipe_usage_rule)
m.must_build = pyomo.Constraint(
m.edge,
doc='Pipe must be built if must_build == 1',
rule=must_build_rule)
m.build_capacity = pyomo.Constraint(
m.edge,
doc='Pipe capacity Pmax must be smaller than edge attribute cap_max',
rule=build_capacity_rule)
m.unidirectionality = pyomo.Constraint(
m.edge, m.timesteps,
doc='Power flow only in one direction per timestep',
rule=unidirectionality_rule)
m.symmetry_x = pyomo.Constraint(
m.edge,
doc='Pipe may be used in both directions, if built',
rule=symmetry_x_rule)
m.symmetry_Pmax = pyomo.Constraint(
m.edge,
doc='Pipe has same capacity in both directions, if built',
rule=symmetry_Pmax_rule)
m.built_then_use = pyomo.Constraint(
m.edge, m.timesteps,
doc='Demand must be satisfied from at least one direction, if built',
rule=built_then_use_rule)
m.source_vertices = pyomo.Constraint(
m.vertex, m.timesteps,
doc='Non-zero source term Q is only allowed in source vertices',
rule=source_vertices_rule)
# Objective
m.def_costs = pyomo.Constraint(
m.cost_types,
doc='Cost definitions by type',
rule=cost_rule)
m.obj = pyomo.Objective(
sense=pyomo.minimize,
doc='Minimize costs = network + heat - revenue',
rule=obj_rule)
return m
