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,