def egret_avail():
try:
import egret
except:
return False
p = str(egret.__path__)
l = p.find("'")
r = p.find("'", l + 1)
egretrootpath = p[l + 1:r]
egret_thirdparty_path = os.path.join(egretrootpath, "thirdparty")
if os.path.exists(os.path.join(egret_thirdparty_path, "pglib-opf-master")):
return True
from egret.thirdparty.get_pglib_opf import get_pglib_opf
get_pglib_opf(egret_thirdparty_path)
return True
def test_get_pglib_opf():
# go one level before the repository folder
# Egret-1/egret/thirdparty/tests
repos_parent_path = \
os.path.dirname(
os.path.dirname(
os.path.dirname(
os.path.dirname(
os.path.dirname(_this_file)
)
)
)
)
downloads_dir = os.path.join(repos_parent_path, 'downloads_test')
pglib_dir = os.path.join(downloads_dir, 'pglib-opf-master')
get_pglib_opf(downloads_dir)
assert os.path.isfile(os.path.join(pglib_dir, 'LICENSE'))
def setUpClass(self):
download_dir = os.path.join(current_dir, 'transmission_test_instances')
if not os.path.exists(os.path.join(download_dir, 'pglib-opf-master')):
from egret.thirdparty.get_pglib_opf import get_pglib_opf
get_pglib_opf(download_dir)
class TestDecompose(unittest.TestCase):
def helper(self, case, min_partition_ratio, expected_termination):
test_dir = os.path.dirname(os.path.abspath(__file__))
pglib_dir = os.path.join(test_dir, 'pglib-opf-master')
if not os.path.isdir(pglib_dir):
get_pglib_opf(download_dir=test_dir)
md = ModelData.read(filename=os.path.join(pglib_dir, case))
m, scaled_md = create_rsv_acopf_model(md)
relaxed_m = coramin.relaxations.relax(
m,
in_place=False,
use_fbbt=True,
fbbt_options={
'deactivate_satisfied_constraints': True,
'max_iter': 2
})
(decomposed_m, component_map,
termination_reason) = decompose_model(model=relaxed_m,
max_leaf_nnz=1000,
min_partition_ratio=1.4,
limit_num_stages=True)
self.assertEqual(termination_reason, expected_termination)
for r in coramin.relaxations.relaxation_data_objects(block=relaxed_m,
descend_into=True,
active=True,
sort=True):
r.rebuild(build_nonlinear_constraint=True)
for r in coramin.relaxations.relaxation_data_objects(
block=decomposed_m, descend_into=True, active=True, sort=True):
r.rebuild(build_nonlinear_constraint=True)
opt = pe.SolverFactory('ipopt')
res = opt.solve(m, tee=False)
relaxed_res = opt.solve(relaxed_m, tee=False)
decomposed_res = opt.solve(decomposed_m, tee=False)
self.assertEqual(res.solver.termination_condition,
pe.TerminationCondition.optimal)
self.assertEqual(relaxed_res.solver.termination_condition,
pe.TerminationCondition.optimal)
self.assertEqual(decomposed_res.solver.termination_condition,
pe.TerminationCondition.optimal)
obj = get_objective(m)
relaxed_obj = get_objective(relaxed_m)
decomposed_obj = get_objective(decomposed_m)
val = pe.value(obj.expr)
relaxed_val = pe.value(relaxed_obj.expr)
decomposed_val = pe.value(decomposed_obj.expr)
relaxed_rel_diff = abs(val - relaxed_val) / val
decomposed_rel_diff = abs(val - decomposed_val) / val
self.assertAlmostEqual(relaxed_rel_diff, 0)
self.assertAlmostEqual(decomposed_rel_diff, 0)
relaxed_vars = list(
coramin.relaxations.nonrelaxation_component_data_objects(
relaxed_m, pe.Var, sort=True, descend_into=True))
relaxed_cons = list(
coramin.relaxations.nonrelaxation_component_data_objects(
relaxed_m,
pe.Constraint,
active=True,
sort=True,
descend_into=True))
relaxed_rels = list(
coramin.relaxations.relaxation_data_objects(relaxed_m,
descend_into=True,
active=True,
sort=True))
decomposed_vars = list(
coramin.relaxations.nonrelaxation_component_data_objects(
decomposed_m, pe.Var, sort=True, descend_into=True))
decomposed_cons = list(
coramin.relaxations.nonrelaxation_component_data_objects(
decomposed_m,
pe.Constraint,
active=True,
sort=True,
descend_into=True))
decomposed_rels = list(
coramin.relaxations.relaxation_data_objects(decomposed_m,
descend_into=True,
active=True,
sort=True))
linking_cons = list()
for stage in range(decomposed_m.num_stages()):
for block in decomposed_m.stage_blocks(stage):
if not block.is_leaf():
linking_cons.extend(block.linking_constraints.values())
relaxed_vars_mapped = list()
for i in relaxed_vars:
relaxed_vars_mapped.append(component_map[i])
var_diff = ComponentSet(decomposed_vars) - ComponentSet(
relaxed_vars_mapped)
vars_in_linking_cons = ComponentSet()
for c in linking_cons:
for v in identify_variables(c.body, include_fixed=True):
vars_in_linking_cons.add(v)
for v in var_diff:
self.assertIn(v, vars_in_linking_cons)
var_diff = ComponentSet(relaxed_vars_mapped) - ComponentSet(
decomposed_vars)
self.assertEqual(len(var_diff), 0)
self.assertEqual(
len(relaxed_vars) + len(linking_cons), len(decomposed_vars))
self.assertEqual(
len(relaxed_cons) + len(linking_cons), len(decomposed_cons))
self.assertEqual(len(relaxed_rels), len(decomposed_rels))
tightening. The example problem is an ACOPF problem.
"""
import pyomo.environ as pe
import coramin
from egret.data.model_data import ModelData
from egret.thirdparty.get_pglib_opf import get_pglib_opf
from egret.models.ac_relaxations import create_polar_acopf_relaxation
from egret.models.acopf import create_psv_acopf_model
import itertools
import os
import time
# Create the NLP and the relaxation
print('Downloading Power Grid Lib')
if not os.path.exists('pglib-opf-master'):
get_pglib_opf()
print('Creating NLP and relaxation')
md = ModelData.read('pglib-opf-master/api/pglib_opf_case73_ieee_rts__api.m')
nlp, scaled_md = create_psv_acopf_model(md)
relaxation, scaled_md2 = create_polar_acopf_relaxation(md)
# perform decomposition
print('Decomposing relaxation')
relaxation, component_map, termination_reason = coramin.domain_reduction.decompose_model(
relaxation, max_leaf_nnz=1000)
# Add more outer approximation points for the second order cone constraints
print('Adding extra outer-approximation points for SOC constraints')
for b in coramin.relaxations.relaxation_data_objects(relaxation,
descend_into=True,
