def test_soc_model(self, case_name):
test_case = os.path.join(current_dir, 'transmission_test_instances',
'pglib-opf-master', '{}.m'.format(case_name))
upper_bound_soln = upper_bounds[case_name]
gap_soln = gaps[case_name]
md = create_ModelData(test_case)
nlp, scaled_md = create_psv_acopf_model(md)
rel, scaled_md = create_soc_relaxation(md)
opt = SolverFactory('ipopt')
opt.options['linear_solver'] = 'mumps'
res = opt.solve(nlp, tee=False)
self.assertTrue(
res.solver.termination_condition == TerminationCondition.optimal)
ub = pe.value(nlp.obj)
res = opt.solve(rel, tee=False)
self.assertTrue(
res.solver.termination_condition == TerminationCondition.optimal)
lb = pe.value(rel.obj)
gap = (ub - lb) / ub * 100
comparison = math.isclose(ub, upper_bound_soln, rel_tol=1e-4)
self.assertTrue(comparison)
comparison = math.isclose(gap, gap_soln, abs_tol=1e-2)
self.assertTrue(comparison)
def test_ptdf_losses_dcopf_model(self,
test_case,
soln_case,
include_kwargs=False):
dcopf_losses_model = create_ptdf_losses_dcopf_model
md_soln = ModelData.read(soln_case)
md_dict = create_ModelData(test_case)
from egret.models.acopf import solve_acopf
md_dict, _, _ = solve_acopf(md_dict,
"ipopt",
solver_tee=False,
return_model=True,
return_results=True)
kwargs = {}
if include_kwargs:
kwargs = {'include_feasibility_slack': True}
md, results = solve_dcopf_losses(
md_dict,
"ipopt",
dcopf_losses_model_generator=dcopf_losses_model,
solver_tee=False,
return_results=True,
**kwargs)
self.assertTrue(results.solver.termination_condition ==
TerminationCondition.optimal)
comparison = math.isclose(md.data['system']['total_cost'],
md_soln.data['system']['total_cost'],
rel_tol=1e-6)
self.assertTrue(comparison)
def test_polar_relaxation(self, case_name):
test_case = os.path.join(current_dir, 'transmission_test_instances',
'pglib-opf-master', '{}.m'.format(case_name))
upper_bound_soln = upper_bounds[case_name]
md = create_ModelData(test_case)
nlp, scaled_md = create_polar_acopf_relaxation(
md, include_soc=False, use_linear_relaxation=True)
for b in coramin.relaxations.relaxation_data_objects(nlp,
descend_into=True,
active=True,
sort=True):
if isinstance(b, (coramin.relaxations.PWCosRelaxationData,
coramin.relaxations.PWSinRelaxationData)):
v = b.get_rhs_vars()[0]
v.setlb(max(-math.pi / 2, v.lb))
v.setub(min(math.pi / 2, v.ub))
b.rebuild(build_nonlinear_constraint=True)
opt = SolverFactory('ipopt')
opt.options['linear_solver'] = 'mumps'
res = opt.solve(nlp, tee=False)
self.assertTrue(
res.solver.termination_condition == TerminationCondition.optimal)
ub = pe.value(get_obj(nlp))
comparison = math.isclose(ub, upper_bound_soln, rel_tol=1e-4)
self.assertTrue(comparison)
def test_ptdf_serialization_deserialization(self, test_case, soln_case):
dcopf_model = create_ptdf_dcopf_model
md_dict = create_ModelData(test_case)
kwargs = {'ptdf_options': {'save_to': test_case + '.pickle'}}
md_serialization, results = solve_dcopf(
md_dict,
"ipopt",
dcopf_model_generator=dcopf_model,
solver_tee=False,
return_results=True,
**kwargs)
self.assertTrue(results.solver.termination_condition ==
TerminationCondition.optimal)
self.assertTrue(os.path.isfile(test_case + '.pickle'))
kwargs = {'ptdf_options': {'load_from': test_case + '.pickle'}}
md_deserialization, results = solve_dcopf(
md_dict,
"ipopt",
dcopf_model_generator=dcopf_model,
solver_tee=False,
return_results=True,
**kwargs)
self.assertTrue(results.solver.termination_condition ==
TerminationCondition.optimal)
comparison = math.isclose(
md_serialization.data['system']['total_cost'],
md_deserialization.data['system']['total_cost'],
rel_tol=1e-6)
self.assertTrue(comparison)
def _md_dict(cb_data):
p = str(egret.__path__)
l = p.find("'")
r = p.find("'", l + 1)
egretrootpath = p[l + 1:r]
test_case = egretrootpath + cb_data["epath"]
# look at egret/data/model_data.py for the format specification of md_dict
return create_ModelData(test_case)
def test_acopf_model(self, test_case, soln_case):
md_soln = ModelData.read(soln_case)
md_dict = create_ModelData(test_case)
model, scaled_md = create_atan_acopf_model(md_dict)
opt = pe.SolverFactory('ipopt')
res = opt.solve(model)
self.assertTrue(res.solver.termination_condition == TerminationCondition.optimal)
self.assertAlmostEqual(pe.value(model.obj)/md_soln.data['system']['total_cost'], 1, 4)
def _md_dict(epath):
p = str(egret.__path__)
l = p.find("'")
r = p.find("'", l + 1)
egretrootpath = p[l + 1:r]
if epath[0] != os.sep:
test_case = os.path.join(egretrootpath, epath)
else:
test_case = os.path.join(egretrootpath, epath[1:])
# look at egret/data/model_data.py for the format specification of md_dict
return create_ModelData(test_case)
def test_copperplate_dispatch_model(self, test_case, soln_case, include_kwargs=False):
md_soln = ModelData.read(soln_case)
md_dict = create_ModelData(test_case)
kwargs = {}
if include_kwargs:
kwargs = {'include_feasibility_slack':True}
md, results = solve_copperplate_dispatch(md_dict, "ipopt", solver_tee=False, return_results=True, **kwargs)
self.assertTrue(results.solver.termination_condition == TerminationCondition.optimal)
comparison = math.isclose(md.data['system']['total_cost'], md_soln.data['system']['total_cost'], rel_tol=1e-6)
self.assertTrue(comparison)
def test_acopf_model(self, test_case, soln_case, p_and_v_soln_case, include_kwargs=False):
acopf_model = create_psv_acopf_model
md_soln = ModelData.read(soln_case)
md_dict = create_ModelData(test_case)
kwargs = {}
if include_kwargs:
kwargs = {'include_feasibility_slack':True}
md, results = solve_acopf(md_dict, "ipopt", acopf_model_generator=acopf_model, solver_tee=False, return_results=True, **kwargs)
self.assertTrue(results.solver.termination_condition == TerminationCondition.optimal)
comparison = math.isclose(md.data['system']['total_cost'], md_soln.data['system']['total_cost'], rel_tol=1e-6)
self.assertTrue(comparison)
_test_p_and_v(self, p_and_v_soln_case, md)
def test_acpf_model(self, test_case, soln_case, include_kwargs=False):
# md_soln = ModelData.read(soln_case)
md_dict = create_ModelData(test_case)
kwargs = {}
if include_kwargs:
kwargs = {'include_feasibility_slack': True}
md, m, results = acpf.solve_acpf(
md_dict,
"ipopt",
acpf_model_generator=acpf.create_psv_acpf_model,
solver_tee=True,
return_results=True,
return_model=True,
**kwargs)
self.assertTrue(results.solver.termination_condition ==
TerminationCondition.optimal)
# check the solution
with open(soln_case, 'r') as fd:
soln = json.load(fd)
gens = dict(md.elements(element_type='generator'))
buses = dict(md.elements(element_type='bus'))
gen_attrs = md.attributes(element_type='generator')
bus_attrs = md.attributes(element_type='bus')
gens_by_bus = tx_utils.gens_by_bus(buses, gens)
for b in gens_by_bus:
genlist = gens_by_bus[b]
pg1 = 0
pg2 = 0
qg1 = 0
qg2 = 0
for g in genlist:
pg1 += gen_attrs['pg'][g]
pg2 += soln['pg'][g]
qg1 += gen_attrs['qg'][g]
qg2 += soln['qg'][g]
self.assertAlmostEqual(1e-3 * pg1, 1e-3 * pg2, places=4)
self.assertAlmostEqual(1e-3 * qg1, 1e-3 * qg2, places=4)
bus_attrs = md.attributes(element_type='bus')
for k in bus_attrs['vm'].keys():
self.assertAlmostEqual(bus_attrs['vm'][k], soln['vm'][k], places=3)
self.assertAlmostEqual(bus_attrs['va'][k], soln['va'][k], places=3)
def populate_md_dict(self):
if self.test_case == "RTS-GMLC":
begin_time = "2020-01-27 00:00:00"
end_time = "2020-01-28 00:00:00"
md_dict = rtsparser.create_ModelData(self.cb_data["epath"],
begin_time,
end_time,
simulation="DAY_AHEAD",
t0_state=None)
self.md_dict = util.from_piecewise_to_quadratic(md_dict)
else:
self.md_dict = create_ModelData(self.cb_data["epath"])
if self.verbose:
print("start data dump")
print(list(self.md_dict.elements("generator")))
for this_branch in self.md_dict.elements("branch"):
print("TYPE=", type(this_branch))
print("B=", this_branch)
print("IN SERVICE=", this_branch[1]["in_service"])
print("GENERATOR SET=", self.md_dict.attributes("generator"))
print("end data dump")
# lines = list()
# for j, this_branch in enumerate(self.md_dict.elements("branch")):
# lines.append(str(j + 1))
# lines.append(this_branch[0])
if self.line_failure_off:
self.a_line_fails_prob = 0 #0 proba of falling the rest is generarion
self.generatorscenarios = scenario_creation_windpower.getwindturbineScenarios(
self.branching_factors[0]) if self.generator_scenario else None
self.cb_data["etree"] = etree.ACTree(
self.number_of_stages,
self.branching_factors,
self.seed,
self.acstream,
self.a_line_fails_prob,
self.stage_duration_minutes,
self.repair_fct,
list(self.md_dict.data["elements"]["branch"].keys()),
list(self.md_dict.data["elements"]["generator"].keys()),
GeneratorScenarios=self.generatorscenarios,
first_time=self.first_time)
def test_atan_relaxation(self, case_name):
test_case = os.path.join(current_dir, 'transmission_test_instances',
'pglib-opf-master', '{}.m'.format(case_name))
upper_bound_soln = upper_bounds[case_name]
md = create_ModelData(test_case)
nlp, scaled_md = create_atan_relaxation(md, use_linear_relaxation=True)
for b in coramin.relaxations.relaxation_data_objects(nlp,
descend_into=True,
active=True,
sort=True):
b.rebuild(build_nonlinear_constraint=True)
opt = SolverFactory('ipopt')
opt.options['linear_solver'] = 'mumps'
res = opt.solve(nlp, tee=False)
self.assertTrue(
res.solver.termination_condition == TerminationCondition.optimal)
ub = pe.value(get_obj(nlp))
comparison = math.isclose(ub, upper_bound_soln, rel_tol=1e-4)
self.assertTrue(comparison)
return md, m, results
elif return_model:
return md, m
elif return_results:
return md, results
return md
if __name__ == '__main__':
import os
from egret.parsers.matpower_parser import create_ModelData
path = os.path.dirname(__file__)
filename = 'pglib_opf_case14_ieee.m'
matpower_file = os.path.join(path, '../../download/pglib-opf/', filename)
model_data = create_ModelData(matpower_file)
kwargs = {'include_feasibility_slack': False}
md, m, results = solve_acopf(model_data,
"ipopt",
acopf_model_generator=create_psv_acopf_model,
return_model=True,
return_results=True,
**kwargs)
md, m, results = solve_acopf(model_data,
"ipopt",
acopf_model_generator=create_rsv_acopf_model,
return_model=True,
return_results=True,
**kwargs)
md, m, results = solve_acopf(model_data,
"ipopt",
if __name__ == '__main__':
import os
from egret.parsers.matpower_parser import create_ModelData
path = os.path.dirname(__file__)
power_types = ["Reactive", "Active"]
bus_types = ["from_bus", "to_bus"]
case = 'case14_ieee'
filename = 'pglib_opf_' + case + '.m'
test_case = os.path.join('c:\\', 'Users', 'wlinz', 'Desktop', 'Restoration', 'Egret', 'egret', 'thirdparty', 'pglib-opf-master', filename) #Better if this isn't so user-dependent
md_dict = create_ModelData(test_case)
md = md_dict.clone_in_service()
branches = dict(md.elements(element_type='branch'))
branch_attrs = md.attributes(element_type='branch')
json_filename = case + '_delta_4_curvature_partition.json'
with open(json_filename, "r") as read_file:
full_branches_dict = json.load(read_file)
branch_av_sq_diff_dict = dict([])
for bus_type in bus_types:
for power_type in power_types:
from math import pi, radians, sqrt
from egret.models.acopf import _include_feasibility_slack, solve_acopf, create_psv_acopf_model, create_rsv_acopf_model
from egret.models.lpac import create_cold_start_lpac_model, solve_lpac
if __name__ == '__main__':
import os
from egret.parsers.matpower_parser import create_ModelData
filename = 'pglib_opf_case30_ieee.m'
test_case = os.path.join('c:\\', 'Users', 'wlinz', 'Desktop',
'Restoration', 'Egret', 'egret', 'thirdparty',
'pglib-opf-master',
filename) #Better if this isn't so user-dependent
model_data = create_ModelData(test_case)
baron_options = {
'LPSol': 8
} # 'CplexLibName': "C:/Program Files/IBM/ILOG/CPLEX_Studio129/cplex/bin/x64_win64/cplex1290.dll"}
knitro_options = {'maxit': 20000}
kwargs = {'include_feasibility_slack': False}
kwargs_for_lpac = {}
#md,m,results = solve_lpac(model_data, "baron",options=baron_options,lpac_model_generator=create_cold_start_lpac_model,return_model=True, return_results=True,**kwargs)
#md,m,results = solve_lpac(model_data, "knitroampl",options=knitro_options,lpac_model_generator=create_hot_start_lpac_model,return_model=True, return_results=True,**kwargs)
#md,m,results = solve_lpac(model_data, "knitroampl",options=knitro_options,lpac_model_generator=create_warm_start_lpac_model,return_model=True, return_results=True,**kwargs)
md, m, results = solve_lpac(
model_data,
"cplex",
lpac_model_generator=create_cold_start_lpac_model,
return_model=True,
return_results=True,
