Add comments and fix dc losses

Signed-off-by: Denis Bonnand <[email protected]>

Author: Denis Bonnand

pypowsybl/opf/impl/bounds/dc_node_voltage_bounds.py

@@ -16,8 +16,8 @@ def add(self, parameters: ModelParameters, network_cache: NetworkCache,
             variable_context: VariableContext, model: ipopt.Model):
         for dc_node_num, row in enumerate(network_cache.dc_nodes.itertuples()):
             #TODO add voltage limits in DC NODE core modelization
-            low_voltage_limit = -1.2
-            high_voltage_limit = 1.2
+            low_voltage_limit = -1
+            high_voltage_limit = 1
             v_bounds = Bounds(low_voltage_limit, high_voltage_limit)
             logger.log(TRACE_LEVEL, f"Add voltage magnitude bounds {v_bounds} to dc_node '{row.Index}' (num={dc_node_num})'")
             model.set_variable_bounds(variable_context.v_dc_vars[dc_node_num],

pypowsybl/opf/impl/bounds/voltage_source_converter_power_bounds.py

@@ -17,8 +17,8 @@ def add(self, parameters: ModelParameters, network_cache: NetworkCache,
         # Voltage source converter active and reactive power bounds
         for converter_num, row in enumerate(network_cache.voltage_source_converters.itertuples()):
             #TODO implements max P, Q in converter core modelization
-            max_p = 100000.0
-            max_q = 100000.0
+            max_p = 100.0
+            max_q = 100.0
             p_bounds = Bounds(-max_p, max_p).mirror()
             logger.log(TRACE_LEVEL,
                        f"Add active power bounds {p_bounds} to converter '{row.Index}' (num={converter_num})")

pypowsybl/opf/impl/constraints/voltage_source_converter_constraints.py

@@ -33,12 +33,8 @@ def add(self, parameters: ModelParameters, network_cache: NetworkCache, variable
                 if control_mode == "P_PCC":
                     p_ac_eq = conv_p_var - target_p
                     model.add_nl_constraint(p_ac_eq == 0.0)
-                # elif control_mode == "V_DC":
-                #     if dc_connected2:
-                #         dc_node_v_eq = v1_var - v2_var - target_v_dc
-                #     else:
-                #         dc_node_v_eq = v1_var - target_v_dc
-                #     model.add_nl_constraint(dc_node_v_eq == 0.0)
+
+                # if control_mode == "V_DC", we let the opf determine the value of U
 
                 if voltage_regulator_on:
                     bus_v_eq = bus_v_var - target_v_ac
@@ -47,11 +43,17 @@ def add(self, parameters: ModelParameters, network_cache: NetworkCache, variable
                     q_ac_eq = conv_q_var - target_q
                     model.add_nl_constraint(q_ac_eq == 0.0)
 
+                # P_loss = loss_1 + loss_2*I_ac + loss_3*I_ac**2 with the 3 loss coefficients
                 i_ac_var = nl.sqrt(nl.pow(conv_p_var,2) + nl.pow(conv_q_var,2))/1000.0
                 p_loss = idle_loss + switching_loss*i_ac_var + resistive_loss*nl.pow(i_ac_var,2)
+
+                u_var = 0
+                if dc_connected1:
+                    u_var+= v1_var
                 if dc_connected2:
-                    conv_p_dc_eq = (-conv_p_var - p_loss) - conv_i_var*(v1_var - v2_var + 0.001)
-                else:
-                    conv_p_dc_eq = (-conv_p_var - p_loss) - conv_i_var * (v1_var + 0.001)
+                    u_var-= v2_var
+                # P_dc = -P_ac - P_loss because we consider that the power P_dc injected in DC is positive,
+                # and the power P_ac flowing out of AC is negative
+                conv_p_dc_eq = (-conv_p_var - p_loss) - conv_i_var * (u_var + 0.001)
 
                 model.add_nl_constraint(conv_p_dc_eq == 0.0)

pypowsybl/opf/impl/costs/maximal_dc_voltage_cost_function.py

@@ -13,21 +13,5 @@ def __init__(self):
     def create(self, network_cache: NetworkCache, variable_context: VariableContext) -> ExprBuilder:
         cost = poi.ExprBuilder()
         for dc_line_num, dc_line_row in enumerate(network_cache.dc_lines.itertuples()):
-            p_line_loss = dc_line_row.r * variable_context.closed_dc_line_i1_vars[dc_line_num]*variable_context.closed_dc_line_i1_vars[dc_line_num]
-            cost+= p_line_loss
-        # for conv_num, conv_row in enumerate(network_cache.voltage_source_converters.itertuples()):
-        #     if conv_row.bus_id:
-        #         conv_q_var = variable_context.conv_q_vars[conv_num]
-        #         conv_p_var = variable_context.conv_p_vars[conv_num]
-        #         cost += conv_q_var * conv_q_var + conv_p_var * conv_p_var
-        #         if conv_row.dc_connected1 and conv_row.dc_connected2:
-        #             dc_node1_num = network_cache.dc_nodes.index.get_loc(conv_row.dc_node1_id)
-        #             dc_node2_num = network_cache.dc_nodes.index.get_loc(conv_row.dc_node2_id)
-        #             v1_var = variable_context.v_dc_vars[dc_node1_num]
-        #             v2_var = variable_context.v_dc_vars[dc_node2_num]
-        #             cost += (v1_var - v2_var) * (v1_var - v2_var)
-        #         elif conv_row.dc_connected1:
-        #             dc_node1_num = network_cache.dc_nodes.index.get_loc(conv_row.dc_node1_id)
-        #             v1_var = variable_context.v_dc_vars[dc_node1_num]
-        #             cost += v1_var * v1_var
+            cost+= variable_context.closed_dc_line_i1_vars[dc_line_num]**2 + variable_context.closed_dc_line_i2_vars[dc_line_num]**2
         return cost

pypowsybl/opf/impl/costs/minimize_dc_losses.py

@@ -254,6 +254,7 @@ def build(network_cache: NetworkCache, model: ipopt.Model) -> 'VariableContext':
             converter_nums.append(converter_num)
         conv_p_vars = model.add_m_variables(len(converter_nums), name="conv_p_vars")
         conv_q_vars = model.add_m_variables(len(converter_nums), name="conv_q_vars")
+        # for one converter, conv_i is the DC current flowing from dc_node1 to dc_node2
         conv_i_vars = model.add_m_variables(len(converter_nums), name="conv_i_vars")
 
         return VariableContext(v_vars, ph_vars,

pypowsybl/opf/impl/model/variable_context.py

@@ -30,7 +30,6 @@
 from pypowsybl.opf.impl.constraints.dc_ground_constraints import DcGroundConstraints
 from pypowsybl.opf.impl.costs.minimize_against_reference_cost_function import MinimizeAgainstReferenceCostFunction
 from pypowsybl.opf.impl.costs.redispatching_cost_function import RedispatchingCostFunction
-from pypowsybl.opf.impl.costs.maximal_dc_voltage_cost_function import MaximalDcVoltageCostFunction
 from pypowsybl.opf.impl.costs.minimize_dc_losses import MinimizeDcLossesFunction
 from pypowsybl.opf.impl.model.bounds import Bounds
 from pypowsybl.opf.impl.model.constraints import Constraints
@@ -91,21 +90,20 @@ def run(self, parameters: OptimalPowerFlowParameters) -> bool:
             constraints.append(CurrentLimitConstraints())
             cost_function = RedispatchingCostFunction(1.0, 1.0, 1.0)
         else:
-            # cost_function = MinimizeAgainstReferenceCostFunction()
-            # cost_function = MaximalDcVoltageCostFunction()
             cost_function = MinimizeDcLossesFunction()
         model_parameters = ModelParameters(parameters.reactive_bounds_reduction,
                                            parameters.twt_split_shunt_admittance,
                                            Bounds(parameters.default_voltage_bounds[0], parameters.default_voltage_bounds[1]))
         opf_model = OpfModel.build(network_cache, model_parameters, variable_bounds, constraints, cost_function)
 
+        #BATTERY don't have target_v attribute and VSC_CONVERTER no target_p
         network_stats = NetworkStatistics(network_cache)
         network_stats.add(ElementType.GENERATOR, 'target_v')
-        network_stats.add(ElementType.BATTERY, 'target_v')
+        # network_stats.add(ElementType.BATTERY, 'target_v')
         network_stats.add(ElementType.VSC_CONVERTER_STATION, 'target_v')
         network_stats.add(ElementType.GENERATOR, 'target_p')
         network_stats.add(ElementType.BATTERY, 'target_p')
-        network_stats.add(ElementType.VSC_CONVERTER_STATION, 'target_p')
+        # network_stats.add(ElementType.VSC_CONVERTER_STATION, 'target_p')
 
         logger.info("Starting optimization...")
         start = time.perf_counter()

pypowsybl/opf/impl/opf.py

@@ -80,16 +80,13 @@ def run_opf_then_lf(network: pp.network.Network,
     print(network.get_voltage_source_converters())
     print(network.get_buses())
     print(network.get_lines())
+
+    # validate is not implemented for DC components yet
     # validate(network, lf_parameters=lf_parameters)
 
     lf_parameters.voltage_init_mode = pp.loadflow.VoltageInitMode.PREVIOUS_VALUES
     lf_result = pp.loadflow.run_ac(network, lf_parameters)
-    print(network.get_dc_nodes())
-    print(network.get_dc_lines())
-    print(network.get_voltage_source_converters())
-    print(network.get_buses())
-    print(network.get_lines())
-    print(lf_result[0].status)
+
     assert lf_result[0].status == pp.loadflow.ComponentStatus.CONVERGED
     assert lf_result[0].iteration_count == iteration_count
 
@@ -222,23 +219,13 @@ def test_micro_grid_nl():
     run_opf_then_lf(pp.network.create_micro_grid_nl_network())
 
 def test_ac_dc_network():
-    import logging
-    logging.basicConfig()
-    logging.getLogger('powsybl').setLevel(0)
-    parameters = lf.Parameters(provider_parameters={'maxNewtonRaphsonIterations': '16', 'acDcNetwork': 'True', 'slackBusSelector': 'FIRST'})
-    run_opf_then_lf(pp.network.create_ac_dc_network(), lf_parameters=parameters)
+    parameters = lf.Parameters(provider_parameters={'slackBusSelector': 'FIRST'})
+    run_opf_then_lf(pp.network.create_ac_dc_network(), lf_parameters=parameters, iteration_count=2)
 
 def test_ac_dc_bipolar_network():
-    import logging
-    logging.basicConfig()
-    logging.getLogger('powsybl').setLevel(0)
-    parameters = lf.Parameters(provider_parameters={'maxNewtonRaphsonIterations': '16', 'acDcNetwork': 'True', 'slackBusSelector': 'FIRST'})
-    run_opf_then_lf(pp.network.create_ac_dc_bipolar_network(), lf_parameters=parameters)
+    parameters = lf.Parameters(provider_parameters={'slackBusSelector': 'FIRST'})
+    run_opf_then_lf(pp.network.create_ac_dc_bipolar_network(), lf_parameters=parameters, iteration_count=3)
 
 def test_ac_dc_bipolar_network_with_metallic_return():
-    import logging
-    logging.basicConfig()
-    logging.getLogger('powsybl').setLevel(0)
-    parameters = lf.Parameters(provider_parameters={'maxNewtonRaphsonIterations': '16', 'acDcNetwork': 'True',
-                                                    'slackBusSelector': 'FIRST'})
-    run_opf_then_lf(pp.network.create_ac_dc_bipolar_network_with_metallic_return(), lf_parameters=parameters)
+    parameters = lf.Parameters(provider_parameters={'slackBusSelector': 'FIRST'})
+    run_opf_then_lf(pp.network.create_ac_dc_bipolar_network_with_metallic_return(), lf_parameters=parameters, iteration_count=3)