def test_pareto_sols():
pareto_sols = np.array([
[8, 184],
[9.33, 181.33],
[10.67, 178.67],
[12, 176],
[13.33, 173.33],
[14.67, 170.67],
[16, 168],
[17.33, 165.33],
[18.67, 162.67],
[20, 160],
])
assert Helper.array_equal(py_augmecon.unique_pareto_sols, pareto_sols, 2)
def test_pareto_sols():
pareto_sols = np.array([
[3075000, 62460, 33000],
[3085000, 61980, 32333.33],
[3108333.33, 60860, 30777.78],
[3115000, 60540, 30333.33],
[3131666.67, 59740, 29222.22],
[3155000, 58620, 27666.67],
[3178333.33, 57500, 26111.11],
[3195000, 56700, 25000],
[3201666.67, 56380, 24555.56],
[3225000, 55260, 23000],
[3255000, 54780, 23666.67],
[3375000, 52860, 26333.33],
[3495000, 50940, 29000],
[3615000, 49020, 31666.67],
[3735000, 47100, 34333.33],
[3855000, 45180, 37000],
])
assert Helper.array_equal(py_augmecon.unique_pareto_sols, pareto_sols, 2)
def test_pareto_sols():
pareto_sols = Helper.read_excel(xlsx, "pareto_sols").to_numpy()
assert Helper.array_equal(py_augmecon.unique_pareto_sols, pareto_sols, 2)
def test_payoff_table():
payoff = Helper.read_excel(xlsx, "payoff_table").to_numpy()
assert Helper.array_equal(py_augmecon.model.payoff, payoff, 2)
def test_payoff_table():
payoff = np.array([[20, 160], [8, 184]])
assert Helper.array_equal(py_augmecon.model.payoff, payoff, 2)
def test_payoff_table():
payoff = np.array([[3075000, 62460, 33000], [3855000, 45180, 37000],
[3225000, 55260, 23000]])
assert Helper.array_equal(py_augmecon.model.payoff, payoff, 2)
def unit_commitment_model():
model = ConcreteModel()
# Define input files
xlsx = pd.ExcelFile(
f"{Path(__file__).parent.absolute()}/input/unit_commitment.xlsx",
engine="openpyxl",
)
system_demand = Helper.read_excel(xlsx, "SystemDemand")
storage_systems = Helper.read_excel(xlsx, "StorageSystems")
generators = Helper.read_excel(xlsx, "Generators")
generator_step_size = Helper.read_excel(xlsx, "GeneratorStepSize")
generator_step_cost = Helper.read_excel(xlsx, "GeneratorStepCost")
pv_generation = Helper.read_excel(xlsx, "PVGeneration")
# Define sets
model.T = Set(ordered=True, initialize=system_demand.index)
model.I = Set(ordered=True, initialize=generators.index)
model.F = Set(ordered=True, initialize=generator_step_size.columns)
model.S = Set(ordered=True, initialize=storage_systems.index)
# Define parameters
model.Pmax = Param(model.I, within=NonNegativeReals, mutable=True)
model.Pmin = Param(model.I, within=NonNegativeReals, mutable=True)
model.RU = Param(model.I, within=NonNegativeReals, mutable=True)
model.RD = Param(model.I, within=NonNegativeReals, mutable=True)
model.SUC = Param(model.I, within=NonNegativeReals, mutable=True)
model.SDC = Param(model.I, within=NonNegativeReals, mutable=True)
model.Pini = Param(model.I, within=NonNegativeReals, mutable=True)
model.uini = Param(model.I, within=Binary, mutable=True)
model.C = Param(model.I, model.F, within=NonNegativeReals, mutable=True)
model.B = Param(model.I, model.F, within=NonNegativeReals, mutable=True)
model.SystemDemand = Param(model.T, within=NonNegativeReals, mutable=True)
model.Emissions = Param(model.I, within=NonNegativeReals, mutable=True)
model.PV = Param(model.T, within=NonNegativeReals, mutable=True)
model.ESS_Pmax = Param(model.S, within=NonNegativeReals, mutable=True)
model.ESS_SOEmax = Param(model.S, within=NonNegativeReals, mutable=True)
model.ESS_SOEini = Param(model.S, within=NonNegativeReals, mutable=True)
model.ESS_Eff = Param(model.S, within=NonNegativeReals, mutable=True)
# Give values to parameters of the generators
for i in model.I:
model.Pmin[i] = generators.loc[i, "Pmin"]
model.Pmax[i] = generators.loc[i, "Pmax"]
model.RU[i] = generators.loc[i, "RU"]
model.RD[i] = generators.loc[i, "RD"]
model.SUC[i] = generators.loc[i, "SUC"]
model.SDC[i] = generators.loc[i, "SDC"]
model.Pini[i] = generators.loc[i, "Pini"]
model.uini[i] = generators.loc[i, "uini"]
model.Emissions[i] = generators.loc[i, "Emissions"]
for f in model.F:
model.B[i, f] = generator_step_size.loc[i, f]
model.C[i, f] = generator_step_cost.loc[i, f]
# Add system demand and PV generation
for t in model.T:
model.SystemDemand[t] = system_demand.loc[t, "SystemDemand"]
model.PV[t] = pv_generation.loc[t, "PVGeneration"]
# Give values to ESS parameters
for s in model.S:
model.ESS_Pmax[s] = storage_systems.loc[s, "Power"]
model.ESS_SOEmax[s] = storage_systems.loc[s, "Energy"]
model.ESS_SOEini[s] = storage_systems.loc[s, "SOEini"]
model.ESS_Eff[s] = storage_systems.loc[s, "Eff"]
# Define decision variables
model.P = Var(model.I, model.T, within=NonNegativeReals)
model.Pres = Var(model.T, within=NonNegativeReals)
model.b = Var(model.I, model.F, model.T, within=NonNegativeReals)
model.u = Var(model.I, model.T, within=Binary)
model.CSU = Var(model.I, model.T, within=NonNegativeReals)
model.CSD = Var(model.I, model.T, within=NonNegativeReals)
model.SOE = Var(model.S, model.T, within=NonNegativeReals)
model.Pch = Var(model.S, model.T, within=NonNegativeReals)
model.Pdis = Var(model.S, model.T, within=NonNegativeReals)
model.u_ess = Var(model.S, model.T, within=Binary)
# --------------------------------------
# Define the objective functions
# --------------------------------------
def cost_objective(model):
return sum(
sum(
sum(model.C[i, f] * model.b[i, f, t]
for f in model.F) + model.CSU[i, t] + model.CSD[i, t]
for i in model.I) for t in model.T)
def emissions_objective(model):
return sum(
sum(model.P[i, t] * model.Emissions[i] for i in model.I)
for t in model.T)
def unmet_objective(model):
return sum(model.Pres[t] for t in model.T)
# --------------------------------------
# Define the regular constraints
# --------------------------------------
def power_decomposition_rule1(model, i, t):
return model.P[i, t] == sum(model.b[i, f, t] for f in model.F)
def power_decomposition_rule2(model, i, f, t):
return model.b[i, f, t] <= model.B[i, f]
def power_min_rule(model, i, t):
return model.P[i, t] >= model.Pmin[i] * model.u[i, t]
def power_max_rule(model, i, t):
return model.P[i, t] <= model.Pmax[i] * model.u[i, t]
def ramp_up_rule(model, i, t):
if model.T.ord(t) == 1:
return model.P[i, t] - model.Pini[i] <= 60 * model.RU[i]
if model.T.ord(t) > 1:
return model.P[i, t] - model.P[i,
model.T.prev(t)] <= 60 * model.RU[i]
def ramp_down_rule(model, i, t):
if model.T.ord(t) == 1:
return (model.Pini[i] - model.P[i, t]) <= 60 * model.RD[i]
if model.T.ord(t) > 1:
return (model.P[i, model.T.prev(t)] -
model.P[i, t]) <= 60 * model.RD[i]
def start_up_cost(model, i, t):
if model.T.ord(t) == 1:
return model.CSU[i, t] >= model.SUC[i] * (model.u[i, t] -
model.uini[i])
if model.T.ord(t) > 1:
return model.CSU[i, t] >= model.SUC[i] * (
model.u[i, t] - model.u[i, model.T.prev(t)])
def shut_down_cost(model, i, t):
if model.T.ord(t) == 1:
return model.CSD[i, t] >= model.SDC[i] * (model.uini[i] -
model.u[i, t])
if model.T.ord(t) > 1:
return model.CSD[i, t] >= model.SDC[i] * (
model.u[i, model.T.prev(t)] - model.u[i, t])
def ESS_SOEupdate(model, s, t):
if model.T.ord(t) == 1:
return (model.SOE[s, t] == model.ESS_SOEini[s] +
model.ESS_Eff[s] * model.Pch[s, t] -
model.Pdis[s, t] / model.ESS_Eff[s])
if model.T.ord(t) > 1:
return (model.SOE[s, t] == model.SOE[s, model.T.prev(t)] +
model.ESS_Eff[s] * model.Pch[s, t] -
model.Pdis[s, t] / model.ESS_Eff[s])
def ESS_SOElimit(model, s, t):
return model.SOE[s, t] <= model.ESS_SOEmax[s]
def ESS_Charging(model, s, t):
return model.Pch[s, t] <= model.ESS_Pmax[s] * model.u_ess[s, t]
def ESS_Discharging(model, s, t):
return model.Pdis[s, t] <= model.ESS_Pmax[s] * (1 - model.u_ess[s, t])
def Balance(model, t):
return model.PV[t] + sum(model.P[i, t] for i in model.I) + sum(
model.Pdis[s, t]
for s in model.S) == model.SystemDemand[t] - model.Pres[t] + sum(
model.Pch[s, t] for s in model.S)
def Pres_max(model, t):
return model.Pres[t] <= 0.1 * model.SystemDemand[t]
# --------------------------------------
# Add components to the model
# --------------------------------------
# Add the constraints to the model
model.power_decomposition_rule1 = Constraint(
model.I, model.T, rule=power_decomposition_rule1)
model.power_decomposition_rule2 = Constraint(
model.I, model.F, model.T, rule=power_decomposition_rule2)
model.power_min_rule = Constraint(model.I, model.T, rule=power_min_rule)
model.power_max_rule = Constraint(model.I, model.T, rule=power_max_rule)
model.start_up_cost = Constraint(model.I, model.T, rule=start_up_cost)
model.shut_down_cost = Constraint(model.I, model.T, rule=shut_down_cost)
model.ConSOEUpdate = Constraint(model.S, model.T, rule=ESS_SOEupdate)
model.ConCharging = Constraint(model.S, model.T, rule=ESS_Charging)
model.ConDischarging = Constraint(model.S, model.T, rule=ESS_Discharging)
model.ConSOElimit = Constraint(model.S, model.T, rule=ESS_SOElimit)
model.ConGenUp = Constraint(model.I, model.T, rule=ramp_up_rule)
model.ConGenDown = Constraint(model.I, model.T, rule=ramp_down_rule)
model.ConBalance = Constraint(model.T, rule=Balance)
model.Pres_max = Constraint(model.T, rule=Pres_max)
# Add the objective functions to the model using ObjectiveList(). Note
# that the first index is 1 instead of 0!
model.obj_list = ObjectiveList()
model.obj_list.add(expr=cost_objective(model), sense=minimize)
model.obj_list.add(expr=emissions_objective(model), sense=minimize)
model.obj_list.add(expr=unmet_objective(model), sense=minimize)
# By default deactivate all the objective functions
for o in range(len(model.obj_list)):
model.obj_list[o + 1].deactivate()
return model