def create_explicit_subproblem(model, subproblem, model_data, include_angle_diff_limits=False, include_bigm=False): ### power system data md = model_data ### create dictionaries of object sets gens = dict(md.elements(element_type='generator')) buses = dict(md.elements(element_type='bus')) branches = dict(md.elements(element_type='branch')) loads = dict(md.elements(element_type='load')) shunts = dict(md.elements(element_type='shunt')) ### create dictionaries across object attributes for an object of the same set type gen_attrs = md.attributes(element_type='generator') bus_attrs = md.attributes(element_type='bus') branch_attrs = md.attributes(element_type='branch') inlet_branches_by_bus, outlet_branches_by_bus = \ tx_utils.inlet_outlet_branches_by_bus(branches, buses) gens_by_bus = tx_utils.gens_by_bus(buses, gens) ### declare (and fix) the loads at the buses bus_p_loads, _ = tx_utils.dict_of_bus_loads(buses, loads) buses_with_loads = list(k for k in bus_p_loads.keys() if bus_p_loads[k] != 0.) ### declare load shed variables decl.declare_var('load_shed', subproblem, buses_with_loads, initialize=0.0, domain=pe.NonNegativeReals) #libbus.declare_var_pl(model.subproblem, bus_attrs['names'], initialize=bus_p_loads) #model.subproblem.pl.fix() subproblem.pl = bus_p_loads ### declare the fixed shunts at the buses _, bus_gs_fixed_shunts = tx_utils.dict_of_bus_fixed_shunts(buses, shunts) ### declare the polar voltages va_bounds = {k: (-pi, pi) for k in bus_attrs['va']} va_init = {k: bus_attrs['va'][k] * (pi / 180) for k in bus_attrs['va']} libbus.declare_var_va(subproblem, bus_attrs['names'], initialize=bus_attrs['va'], bounds=va_bounds) ### fix the reference bus ref_bus = md.data['system']['reference_bus'] ref_angle = md.data['system']['reference_bus_angle'] subproblem.va[ref_bus].fix(radians(ref_angle)) ### declare the generator real power pg_init = { k: (gen_attrs['p_min'][k] + gen_attrs['p_max'][k]) / 2.0 for k in gen_attrs['pg'] } libgen.declare_var_pg(subproblem, gen_attrs['names'], initialize=pg_init) ### declare the current flows in the branches vr_init = { k: bus_attrs['vm'][k] * pe.cos(bus_attrs['va'][k]) for k in bus_attrs['vm'] } vj_init = { k: bus_attrs['vm'][k] * pe.sin(bus_attrs['va'][k]) for k in bus_attrs['vm'] } pf_init = dict() for branch_name, branch in branches.items(): from_bus = branch['from_bus'] to_bus = branch['to_bus'] y_matrix = tx_calc.calculate_y_matrix_from_branch(branch) ifr_init = tx_calc.calculate_ifr(vr_init[from_bus], vj_init[from_bus], vr_init[to_bus], vj_init[to_bus], y_matrix) ifj_init = tx_calc.calculate_ifj(vr_init[from_bus], vj_init[from_bus], vr_init[to_bus], vj_init[to_bus], y_matrix) pf_init[branch_name] = tx_calc.calculate_p(ifr_init, ifj_init, vr_init[from_bus], vj_init[from_bus]) libbranch.declare_var_pf(model=subproblem, index_set=branch_attrs['names'], initialize=pf_init) # need to include variable references on subproblem to variables, which exist on the master block #bi.components.varref(subproblem, origin = model) subproblem.add_component("u", Reference(model.u)) subproblem.add_component("v", Reference(model.v)) subproblem.add_component("w", Reference(model.w)) if include_bigm: # create big-M _create_bigm(subproblem, md) ### declare the branch power flow disjuncts subcons.declare_eq_branch_power_btheta_approx_bigM( model=subproblem, index_set=branch_attrs['names'], branches=branches) ### declare the real power flow limits p_max = {k: branches[k]['rating_long_term'] for k in branches.keys()} subcons.declare_ineq_p_branch_thermal_lbub_switch( model=subproblem, index_set=branch_attrs['names'], p_thermal_limits=p_max) else: ### declare the branch power flow with indicator variable in the bilinear term subcons.declare_eq_branch_power_btheta_approx_nonlin( model=subproblem, index_set=branch_attrs['names'], branches=branches) ### declare the real power flow limits p_max = {k: branches[k]['rating_long_term'] for k in branches.keys()} libbranch.declare_ineq_p_branch_thermal_lbub( model=subproblem, index_set=branch_attrs['names'], branches=branches, p_thermal_limits=p_max, approximation_type=ApproximationType.BTHETA) ### declare the load shed subcons.declare_ineq_load_shed(model=subproblem, index_set=buses_with_loads) ### declare the generator compromised subcons.declare_ineq_gen(model=subproblem, index_set=gen_attrs['names'], gens=gens) ### declare the p balance rhs_kwargs = {'include_feasibility_slack_neg': 'load_shed'} libbus.declare_eq_p_balance_dc_approx( model=subproblem, index_set=bus_attrs['names'], bus_p_loads=bus_p_loads, gens_by_bus=gens_by_bus, bus_gs_fixed_shunts=bus_gs_fixed_shunts, inlet_branches_by_bus=inlet_branches_by_bus, outlet_branches_by_bus=outlet_branches_by_bus, approximation_type=ApproximationType.BTHETA, **rhs_kwargs) ### declare angle difference limits on interconnected buses if include_angle_diff_limits: libbranch.declare_ineq_angle_diff_branch_lbub( model=subproblem, index_set=branch_attrs['names'], branches=branches, coordinate_type=CoordinateType.POLAR) ### lower-level objective for interdiction problem (opposite to upper-level objective) subproblem.obj = pe.Objective(expr=sum(subproblem.load_shed[l] for l in buses_with_loads), sense=pe.minimize) return model, md
def _btheta_dcopf_network_model(md,block): buses = dict(md.elements(element_type='bus')) branches = dict(md.elements(element_type='branch')) loads = dict(md.elements(element_type='load')) shunts = dict(md.elements(element_type='shunt')) bus_attrs = md.attributes(element_type='bus') branch_attrs = md.attributes(element_type='branch') inlet_branches_by_bus, outlet_branches_by_bus = \ tx_utils.inlet_outlet_branches_by_bus(branches, buses) ## this is not the "real" gens by bus, but the ## index of net injections from the UC model gens_by_bus = block.gens_by_bus ### declare (and fix) the loads at the buses bus_p_loads, _ = tx_utils.dict_of_bus_loads(buses, loads) libbus.declare_var_pl(block, bus_attrs['names'], initialize=bus_p_loads) block.pl.fix() ### declare the fixed shunts at the buses _, bus_gs_fixed_shunts = tx_utils.dict_of_bus_fixed_shunts(buses, shunts) ### declare the polar voltages va_bounds = {k: (-pi, pi) for k in bus_attrs['names']} libbus.declare_var_va(block, bus_attrs['names'], initialize=None, bounds=va_bounds ) ### fix the reference bus ref_bus = md.data['system']['reference_bus'] block.va[ref_bus].fix(0.0) ref_angle = md.data['system']['reference_bus_angle'] if ref_angle != 0.0: raise ValueError('The BTHETA DCOPF formulation currently only supports' ' a reference bus angle of 0 degrees, but an angle' ' of {} degrees was found.'.format(ref_angle)) p_max = {k: branches[k]['rating_long_term'] for k in branches.keys()} p_lbub = {k: (-p_max[k],p_max[k]) for k in branches.keys()} pf_bounds = p_lbub libbranch.declare_var_pf(model=block, index_set=branch_attrs['names'], initialize=None, bounds=pf_bounds ) ### declare the branch power flow approximation constraints libbranch.declare_eq_branch_power_btheta_approx(model=block, index_set=branch_attrs['names'], branches=branches ) ### declare the p balance libbus.declare_eq_p_balance_dc_approx(model=block, index_set=bus_attrs['names'], bus_p_loads=bus_p_loads, gens_by_bus=gens_by_bus, bus_gs_fixed_shunts=bus_gs_fixed_shunts, inlet_branches_by_bus=inlet_branches_by_bus, outlet_branches_by_bus=outlet_branches_by_bus, approximation_type=ApproximationType.BTHETA ) ### declare the real power flow limits libbranch.declare_ineq_p_branch_thermal_lbub(model=block, index_set=branch_attrs['names'], branches=branches, p_thermal_limits=p_max, approximation_type=ApproximationType.BTHETA ) ### declare angle difference limits on interconnected buses libbranch.declare_ineq_angle_diff_branch_lbub(model=block, index_set=branch_attrs['names'], branches=branches, coordinate_type=CoordinateType.POLAR ) return block
def create_ptdf_dcopf_model(model_data, include_feasibility_slack=False, base_point=BasePointType.FLATSTART, ptdf_options=None): ptdf_options = lpu.populate_default_ptdf_options(ptdf_options) baseMVA = model_data.data['system']['baseMVA'] lpu.check_and_scale_ptdf_options(ptdf_options, baseMVA) md = model_data.clone_in_service() tx_utils.scale_ModelData_to_pu(md, inplace=True) gens = dict(md.elements(element_type='generator')) buses = dict(md.elements(element_type='bus')) branches = dict(md.elements(element_type='branch')) loads = dict(md.elements(element_type='load')) shunts = dict(md.elements(element_type='shunt')) gen_attrs = md.attributes(element_type='generator') ## to keep things in order buses_idx = tuple(buses.keys()) branches_idx = tuple(branches.keys()) inlet_branches_by_bus, outlet_branches_by_bus = \ tx_utils.inlet_outlet_branches_by_bus(branches, buses) gens_by_bus = tx_utils.gens_by_bus(buses, gens) model = pe.ConcreteModel() ### declare (and fix) the loads at the buses bus_p_loads, _ = tx_utils.dict_of_bus_loads(buses, loads) libbus.declare_var_pl(model, buses_idx, initialize=bus_p_loads) model.pl.fix() ### declare the fixed shunts at the buses _, bus_gs_fixed_shunts = tx_utils.dict_of_bus_fixed_shunts(buses, shunts) ### declare the generator real power pg_init = { k: (gen_attrs['p_min'][k] + gen_attrs['p_max'][k]) / 2.0 for k in gen_attrs['pg'] } libgen.declare_var_pg(model, gen_attrs['names'], initialize=pg_init, bounds=zip_items(gen_attrs['p_min'], gen_attrs['p_max'])) ### include the feasibility slack for the system balance p_rhs_kwargs = {} if include_feasibility_slack: p_rhs_kwargs, penalty_expr = _include_system_feasibility_slack( model, gen_attrs, bus_p_loads) ### declare the p balance libbus.declare_eq_p_balance_ed(model=model, index_set=buses_idx, bus_p_loads=bus_p_loads, gens_by_bus=gens_by_bus, bus_gs_fixed_shunts=bus_gs_fixed_shunts, **p_rhs_kwargs) ### declare net withdraw expression for use in PTDF power flows libbus.declare_expr_p_net_withdraw_at_bus( model=model, index_set=buses_idx, bus_p_loads=bus_p_loads, gens_by_bus=gens_by_bus, bus_gs_fixed_shunts=bus_gs_fixed_shunts, ) ### add "blank" power flow expressions libbranch.declare_expr_pf( model=model, index_set=branches_idx, ) ## Do and store PTDF calculation reference_bus = md.data['system']['reference_bus'] PTDF = ptdf_utils.get_ptdf_potentially_from_file(ptdf_options, branches_idx, buses_idx) if PTDF is None: PTDF = ptdf_utils.PTDFMatrix(branches, buses, reference_bus, base_point, ptdf_options, branches_keys=branches_idx, buses_keys=buses_idx) model._PTDF = PTDF model._ptdf_options = ptdf_options ptdf_utils.write_ptdf_potentially_to_file(ptdf_options, PTDF) if ptdf_options['lazy']: ### add "blank" real power flow limits libbranch.declare_ineq_p_branch_thermal_bounds( model=model, index_set=branches_idx, branches=branches, p_thermal_limits=None, approximation_type=None, ) ### add helpers for tracking monitored branches lpu.add_monitored_flow_tracker(model) ### add initial branches to monitored set lpu.add_initial_monitored_branches(model, branches, branches_idx, ptdf_options, PTDF) else: p_max = {k: branches[k]['rating_long_term'] for k in branches.keys()} ## add all the constraints ### declare the branch power flow approximation constraints libbranch.declare_eq_branch_power_ptdf_approx( model=model, index_set=branches_idx, PTDF=PTDF, abs_ptdf_tol=ptdf_options['abs_ptdf_tol'], rel_ptdf_tol=ptdf_options['rel_ptdf_tol'], ) ### add all the limits libbranch.declare_ineq_p_branch_thermal_lbub( model=model, index_set=branches_idx, branches=branches, p_thermal_limits=p_max, approximation_type=ApproximationType.PTDF, ) ### declare the generator cost objective libgen.declare_expression_pgqg_operating_cost(model=model, index_set=gen_attrs['names'], p_costs=gen_attrs['p_cost']) obj_expr = sum(model.pg_operating_cost[gen_name] for gen_name in model.pg_operating_cost) if include_feasibility_slack: obj_expr += penalty_expr model.obj = pe.Objective(expr=obj_expr) return model, md
def create_btheta_dcopf_model(model_data): md = tx_utils.scale_ModelData_to_pu(model_data) gens = dict(md.elements(element_type='generator')) buses = dict(md.elements(element_type='bus')) branches = dict(md.elements(element_type='branch')) loads = dict(md.elements(element_type='load')) shunts = dict(md.elements(element_type='shunt')) gen_attrs = md.attributes(element_type='generator') bus_attrs = md.attributes(element_type='bus') branch_attrs = md.attributes(element_type='branch') load_attrs = md.attributes(element_type='load') shunt_attrs = md.attributes(element_type='shunt') inlet_branches_by_bus, outlet_branches_by_bus = \ tx_utils.inlet_outlet_branches_by_bus(branches, buses) gens_by_bus = tx_utils.gens_in_service_by_bus(buses, gens) model = pe.ConcreteModel() ### declare (and fix) the loads at the buses bus_p_loads, _ = tx_utils.dict_of_bus_loads(buses, loads) libbus.declare_var_pl(model, bus_attrs['names'], initialize=bus_p_loads) model.pl.fix() ### declare the fixed shunts at the buses _, bus_gs_fixed_shunts = tx_utils.dict_of_bus_fixed_shunts(buses, shunts) ### declare the polar voltages va_bounds = {k: (-pi, pi) for k in bus_attrs['va']} libbus.declare_var_va(model, bus_attrs['names'], initialize=bus_attrs['va'], bounds=va_bounds) ### fix the reference bus ref_bus = md.data['system']['reference_bus'] model.va[ref_bus].fix(0.0) ref_angle = md.data['system']['reference_bus_angle'] if ref_angle != 0.0: raise ValueError('The BTHETA DCOPF formulation currently only supports' ' a reference bus angle of 0 degrees, but an angle' ' of {} degrees was found.'.format(ref_angle)) ### declare the generator real power pg_init = { k: (gen_attrs['p_min'][k] + gen_attrs['p_max'][k]) / 2.0 for k in gen_attrs['pg'] } libgen.declare_var_pg(model, gen_attrs['names'], initialize=pg_init, bounds=zip_items(gen_attrs['p_min'], gen_attrs['p_max'])) ### declare the current flows in the branches vr_init = { k: bus_attrs['vm'][k] * pe.cos(bus_attrs['va'][k]) for k in bus_attrs['vm'] } vj_init = { k: bus_attrs['vm'][k] * pe.sin(bus_attrs['va'][k]) for k in bus_attrs['vm'] } p_max = {k: branches[k]['rating_long_term'] for k in branches.keys()} p_lbub = {k: (-p_max[k], p_max[k]) for k in branches.keys()} pf_bounds = p_lbub pf_init = dict() for branch_name, branch in branches.items(): from_bus = branch['from_bus'] to_bus = branch['to_bus'] y_matrix = tx_calc.calculate_y_matrix_from_branch(branch) ifr_init = tx_calc.calculate_ifr(vr_init[from_bus], vj_init[from_bus], vr_init[to_bus], vj_init[to_bus], y_matrix) ifj_init = tx_calc.calculate_ifj(vr_init[from_bus], vj_init[from_bus], vr_init[to_bus], vj_init[to_bus], y_matrix) pf_init[branch_name] = tx_calc.calculate_p(ifr_init, ifj_init, vr_init[from_bus], vj_init[from_bus]) libbranch.declare_var_pf(model=model, index_set=branch_attrs['names'], initialize=pf_init, bounds=pf_bounds) ### declare the branch power flow approximation constraints libbranch.declare_eq_branch_power_dc_approx( model=model, index_set=branch_attrs['names'], branches=branches, approximation_type=ApproximationType.BTHETA) ### declare the p balance libbus.declare_eq_p_balance_dc_approx( model=model, index_set=bus_attrs['names'], bus_p_loads=bus_p_loads, gens_by_bus=gens_by_bus, bus_gs_fixed_shunts=bus_gs_fixed_shunts, inlet_branches_by_bus=inlet_branches_by_bus, outlet_branches_by_bus=outlet_branches_by_bus, approximation_type=ApproximationType.BTHETA) ### declare the real power flow limits libbranch.declare_ineq_p_branch_thermal_lbub( model=model, index_set=branch_attrs['names'], branches=branches, p_thermal_limits=p_max, approximation_type=ApproximationType.BTHETA) ### declare angle difference limits on interconnected buses libbranch.declare_ineq_angle_diff_branch_lbub( model=model, index_set=branch_attrs['names'], branches=branches, coordinate_type=CoordinateType.POLAR) ### declare the generator cost objective libgen.declare_expression_pgqg_operating_cost(model=model, index_set=gen_attrs['names'], p_costs=gen_attrs['p_cost']) obj_expr = sum(model.pg_operating_cost[gen_name] for gen_name in model.pg_operating_cost) model.obj = pe.Objective(expr=obj_expr) return model
def _ptdf_dcopf_network_model(block, tm): m, gens_by_bus, bus_p_loads, bus_gs_fixed_shunts = \ _setup_egret_network_model(block, tm) buses, branches, branches_in_service, branches_out_service, interfaces = \ _setup_egret_network_topology(m, tm) ptdf_options = m._ptdf_options libbus.declare_var_p_nw(block, m.Buses) ### declare net withdraw expression for use in PTDF power flows libbus.declare_eq_p_net_withdraw_at_bus( model=block, index_set=m.Buses, bus_p_loads=bus_p_loads, gens_by_bus=gens_by_bus, bus_gs_fixed_shunts=bus_gs_fixed_shunts, ) ### declare the p balance libbus.declare_eq_p_balance_ed( model=block, index_set=m.Buses, bus_p_loads=bus_p_loads, gens_by_bus=gens_by_bus, bus_gs_fixed_shunts=bus_gs_fixed_shunts, ) ### add "blank" power flow expressions libbranch.declare_expr_pf( model=block, index_set=branches_in_service, ) ### interface setup libbranch.declare_expr_pfi(model=block, index_set=interfaces.keys()) _setup_interface_slacks(m, block, tm) ### Get the PTDF matrix from cache, from file, or create a new one if branches_out_service not in m._PTDFs: buses_idx = tuple(buses.keys()) reference_bus = value(m.ReferenceBus) PTDF = data_utils.get_ptdf_potentially_from_file(ptdf_options, branches_in_service, buses_idx, interfaces=interfaces) ## NOTE: For now, just use a flat-start for unit commitment if PTDF is None: PTDF = data_utils.PTDFMatrix(branches, buses, reference_bus, BasePointType.FLATSTART, ptdf_options, branches_keys=branches_in_service, buses_keys=buses_idx, interfaces=interfaces) m._PTDFs[branches_out_service] = PTDF else: PTDF = m._PTDFs[branches_out_service] ### attach the current PTDF object to this block block._PTDF = PTDF rel_ptdf_tol = m._ptdf_options['rel_ptdf_tol'] abs_ptdf_tol = m._ptdf_options['abs_ptdf_tol'] if ptdf_options['lazy']: ### add "blank" real power flow limits libbranch.declare_ineq_p_branch_thermal_lbub( model=block, index_set=branches_in_service, branches=branches, p_thermal_limits=None, approximation_type=None, ) ### add helpers for tracking monitored branches lpu.add_monitored_branch_tracker(block) else: ### add all the dense constraints p_max = { k: branches[k]['rating_long_term'] for k in branches_in_service } ### declare the branch power flow approximation constraints libbranch.declare_eq_branch_power_ptdf_approx( model=block, index_set=branches_in_service, PTDF=PTDF, abs_ptdf_tol=abs_ptdf_tol, rel_ptdf_tol=rel_ptdf_tol) ### declare the real power flow limits libbranch.declare_ineq_p_branch_thermal_lbub( model=block, index_set=branches_in_service, branches=branches, p_thermal_limits=p_max, approximation_type=ApproximationType.PTDF) ## for now, just add all the interface constraints ## TODO: incorporate into lazy logic ### declare the branch power flow approximation constraints libbranch.declare_eq_interface_power_ptdf_approx( model=block, index_set=interfaces.keys(), PTDF=PTDF, abs_ptdf_tol=abs_ptdf_tol, rel_ptdf_tol=rel_ptdf_tol) ### declare the interface flow limits libbranch.declare_ineq_p_interface_lbub( model=block, index_set=interfaces.keys(), interfaces=interfaces, )
def create_btheta_dcopf_model(model_data, include_angle_diff_limits=False, include_feasibility_slack=False, pw_cost_model='delta'): md = model_data.clone_in_service() tx_utils.scale_ModelData_to_pu(md, inplace = True) gens = dict(md.elements(element_type='generator')) buses = dict(md.elements(element_type='bus')) branches = dict(md.elements(element_type='branch')) loads = dict(md.elements(element_type='load')) shunts = dict(md.elements(element_type='shunt')) dc_branches = dict(md.elements(element_type='dc_branch')) gen_attrs = md.attributes(element_type='generator') bus_attrs = md.attributes(element_type='bus') branch_attrs = md.attributes(element_type='branch') inlet_branches_by_bus, outlet_branches_by_bus = \ tx_utils.inlet_outlet_branches_by_bus(branches, buses) gens_by_bus = tx_utils.gens_by_bus(buses, gens) model = pe.ConcreteModel() ### declare (and fix) the loads at the buses bus_p_loads, _ = tx_utils.dict_of_bus_loads(buses, loads) libbus.declare_var_pl(model, bus_attrs['names'], initialize=bus_p_loads) model.pl.fix() ### declare the fixed shunts at the buses _, bus_gs_fixed_shunts = tx_utils.dict_of_bus_fixed_shunts(buses, shunts) ### declare the polar voltages va_bounds = {k: (-pi, pi) for k in bus_attrs['va']} libbus.declare_var_va(model, bus_attrs['names'], initialize=tx_utils.radians_from_degrees_dict(bus_attrs['va']), bounds=va_bounds ) ### include the feasibility slack for the bus balances p_rhs_kwargs = {} penalty_expr = None if include_feasibility_slack: p_marginal_slack_penalty = _validate_and_extract_slack_penalty(md) p_rhs_kwargs, penalty_expr = _include_feasibility_slack(model, bus_attrs['names'], bus_p_loads, gens_by_bus, gen_attrs, p_marginal_slack_penalty) ### fix the reference bus ref_bus = md.data['system']['reference_bus'] ref_angle = md.data['system']['reference_bus_angle'] model.va[ref_bus].fix(radians(ref_angle)) ### declare the generator real power pg_init = {k: (gen_attrs['p_min'][k] + gen_attrs['p_max'][k]) / 2.0 for k in gen_attrs['pg']} libgen.declare_var_pg(model, gen_attrs['names'], initialize=pg_init, bounds=zip_items(gen_attrs['p_min'], gen_attrs['p_max']) ) ### declare the current flows in the branches vr_init = {k: bus_attrs['vm'][k] * pe.cos(radians(bus_attrs['va'][k])) for k in bus_attrs['vm']} vj_init = {k: bus_attrs['vm'][k] * pe.sin(radians(bus_attrs['va'][k])) for k in bus_attrs['vm']} p_max = {k: branches[k]['rating_long_term'] for k in branches.keys()} p_lbub = dict() for k in branches.keys(): k_pmax = p_max[k] if k_pmax is None: p_lbub[k] = (None, None) else: p_lbub[k] = (-k_pmax,k_pmax) pf_bounds = p_lbub pf_init = dict() for branch_name, branch in branches.items(): from_bus = branch['from_bus'] to_bus = branch['to_bus'] y_matrix = tx_calc.calculate_y_matrix_from_branch(branch) ifr_init = tx_calc.calculate_ifr(vr_init[from_bus], vj_init[from_bus], vr_init[to_bus], vj_init[to_bus], y_matrix) ifj_init = tx_calc.calculate_ifj(vr_init[from_bus], vj_init[from_bus], vr_init[to_bus], vj_init[to_bus], y_matrix) pf_init[branch_name] = tx_calc.calculate_p(ifr_init, ifj_init, vr_init[from_bus], vj_init[from_bus]) libbranch.declare_var_pf(model=model, index_set=branch_attrs['names'], initialize=pf_init, bounds=pf_bounds ) if dc_branches: dcpf_bounds = dict() for k, k_dict in dc_branches.items(): kp_max = k_dict['rating_long_term'] if kp_max is None: dcpf_bounds[k] = (None, None) else: dcpf_bounds[k] = (-kp_max, kp_max) libbranch.declare_var_dcpf(model=model, index_set=dc_branches.keys(), initialize=0., bounds=dcpf_bounds, ) dc_inlet_branches_by_bus, dc_outlet_branches_by_bus = \ tx_utils.inlet_outlet_branches_by_bus(dc_branches, buses) else: dc_inlet_branches_by_bus = None dc_outlet_branches_by_bus = None ### declare the branch power flow approximation constraints libbranch.declare_eq_branch_power_btheta_approx(model=model, index_set=branch_attrs['names'], branches=branches ) ### declare the p balance libbus.declare_eq_p_balance_dc_approx(model=model, index_set=bus_attrs['names'], bus_p_loads=bus_p_loads, gens_by_bus=gens_by_bus, bus_gs_fixed_shunts=bus_gs_fixed_shunts, inlet_branches_by_bus=inlet_branches_by_bus, outlet_branches_by_bus=outlet_branches_by_bus, approximation_type=ApproximationType.BTHETA, dc_inlet_branches_by_bus=dc_inlet_branches_by_bus, dc_outlet_branches_by_bus=dc_outlet_branches_by_bus, **p_rhs_kwargs ) ### declare the real power flow limits libbranch.declare_ineq_p_branch_thermal_lbub(model=model, index_set=branch_attrs['names'], branches=branches, p_thermal_limits=p_max, approximation_type=ApproximationType.BTHETA ) ### declare angle difference limits on interconnected buses if include_angle_diff_limits: libbranch.declare_ineq_angle_diff_branch_lbub(model=model, index_set=branch_attrs['names'], branches=branches, coordinate_type=CoordinateType.POLAR ) # declare the generator cost objective p_costs = gen_attrs['p_cost'] pw_pg_cost_gens = list(libgen.pw_gen_generator(gen_attrs['names'], costs=p_costs)) if len(pw_pg_cost_gens) > 0: if pw_cost_model == 'delta': libgen.declare_var_delta_pg(model=model, index_set=pw_pg_cost_gens, p_costs=p_costs) libgen.declare_pg_delta_pg_con(model=model, index_set=pw_pg_cost_gens, p_costs=p_costs) else: libgen.declare_var_pg_cost(model=model, index_set=pw_pg_cost_gens, p_costs=p_costs) libgen.declare_piecewise_pg_cost_cons(model=model, index_set=pw_pg_cost_gens, p_costs=p_costs) libgen.declare_expression_pg_operating_cost(model=model, index_set=gen_attrs['names'], p_costs=p_costs, pw_formulation=pw_cost_model) obj_expr = sum(model.pg_operating_cost[gen_name] for gen_name in model.pg_operating_cost) if include_feasibility_slack: obj_expr += penalty_expr model.obj = pe.Objective(expr=obj_expr) return model, md