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,