VeraGridEngine 5.4.6__tar.gz → 5.4.7__tar.gz

{veragridengine-5.4.6 → veragridengine-5.4.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VeraGridEngine
-Version: 5.4.6
+Version: 5.4.7
 Summary: VeraGrid is a Power Systems simulation program intended for professional use and research
 Home-page: https://github.com/SanPen/VeraGrid
 Author: Santiago Peñate Vera et. Al.

{veragridengine-5.4.6 → veragridengine-5.4.7}/VeraGridEngine/Compilers/circuit_to_data.py

@@ -4,6 +4,7 @@
 # SPDX-License-Identifier: MPL-2.0
 from __future__ import annotations
 import numpy as np
+from cmath import rect
 from typing import Dict, Union, TYPE_CHECKING
 
 from VeraGridEngine.basic_structures import Logger
@@ -100,12 +101,14 @@ def set_bus_control_voltage(i: int,
     if not use_stored_guess:
         if not bus_voltage_used[i]:
             if remote_control and j > -1 and j != i:
-                # initialize the remote bus voltage to the control value
-                bus_data.Vbus[j] = complex(candidate_Vm, 0)
+                # initialize the remote bus voltage to the control value but preserve angle while updating magnitude
+                existing_angle = np.angle(bus_data.Vbus[j])
+                bus_data.Vbus[j] = rect(candidate_Vm, existing_angle)
                 bus_voltage_used[j] = True
             else:
-                # initialize the local bus voltage to the control value
-                bus_data.Vbus[i] = complex(candidate_Vm, 0)
+                # initialize the local bus voltage to the control value but preserve angle while updating magnitude
+                existing_angle = np.angle(bus_data.Vbus[i])
+                bus_data.Vbus[i] = rect(candidate_Vm, existing_angle)
                 bus_voltage_used[i] = True
 
         elif candidate_Vm != bus_data.Vbus[i]:
@@ -158,12 +161,14 @@ def set_bus_control_voltage_vsc(i: int,
     if not use_stored_guess:
         if not bus_voltage_used[i]:
             if remote_control and j > -1 and j != i:
-                # initialize the remote bus voltage to the control value
-                bus_data.Vbus[j] = complex(candidate_Vm, 0)
+                # initialize the remote bus voltage to the control value but preserve angle while updating magnitude
+                existing_angle = np.angle(bus_data.Vbus[j])
+                bus_data.Vbus[j] = complex(candidate_Vm, 0) * np.exp(1j * existing_angle)
                 bus_voltage_used[j] = True
             else:
-                # initialize the local bus voltage to the control value
-                bus_data.Vbus[i] = complex(candidate_Vm, 0)
+                # initialize the local bus voltage to the control value but preserve angle while updating magnitude
+                existing_angle = np.angle(bus_data.Vbus[i])
+                bus_data.Vbus[i] = complex(candidate_Vm, 0) * np.exp(1j * existing_angle)
                 bus_voltage_used[i] = True
 
         elif candidate_Vm != bus_data.Vbus[i]:
@@ -172,6 +177,67 @@ def set_bus_control_voltage_vsc(i: int,
                              value=candidate_Vm,
                              expected_value=bus_data.Vbus[i])
 
+def set_bus_control_angle_vsc(i: int,
+                                j: int,
+                                remote_control: bool,
+                                bus_name: str,
+                                bus_angle_used: BoolVec,
+                                bus_data: BusData,
+                                candidate_Va: float,
+                                use_stored_guess: bool,
+                                logger: Logger) -> None:
+    """
+    Set the bus control angle
+    :param i: Bus index
+    :param j: Remote Bus index
+    :param remote_control: Using remote control?
+    :param bus_name: Bus name
+    :param bus_angle_used: Array of flags indicating if a bus angle has been modified before
+    :param bus_data: BusData
+    :param candidate_Va: Angle set point that you want to set in degrees
+    :param use_stored_guess: Use the stored seed values?
+    :param logger: Logger
+    """
+    if bus_data.bus_types[i] != BusMode.Slack_tpe.value:  # if it is not Slack
+        if remote_control and j > -1 and j != i:
+            # delete angle control
+            # bus_data.bus_types[j] = BusMode.PQV_tpe.value  # remote bus to PQV type
+            # bus_data.set_bus_mode(j, BusMode.PQV_tpe)
+            bus_data.is_p_controlled[j] = True
+            bus_data.is_q_controlled[j] = True
+            bus_data.is_va_controlled[j] = True
+
+            # bus_data.bus_types[i] = BusMode.P_tpe.value  # local bus to P type
+            # bus_data.set_bus_mode(i, BusMode.P_tpe)
+            bus_data.is_p_controlled[i] = True
+        else:
+            # local angle control controlling q as well
+            # bus_data.bus_types[i] = BusMode.PV_tpe.value  # set as PV
+            # bus_data.set_bus_mode(i, BusMode.PV_tpe)
+            bus_data.is_q_controlled[i] = True
+            bus_data.is_va_controlled[i] = True
+
+    if not use_stored_guess:
+        if not bus_angle_used[i]:
+            if remote_control and j > -1 and j != i:
+                # initialize the remote bus angle to the control value but preserve magnitude while updating angle
+                existing_magnitude = np.abs(bus_data.Vbus[j])
+                bus_data.Vbus[j] = existing_magnitude * np.exp(1j * candidate_Va * np.pi / 180)
+                bus_angle_used[j] = True
+
+            else:
+                # initialize the local bus angle to the control value but preserve magnitude while updating angle
+                existing_magnitude = np.abs(bus_data.Vbus[i])
+                bus_data.Vbus[i] = existing_magnitude * np.exp(1j * candidate_Va * np.pi / 180)
+                bus_angle_used[i] = True
+
+        else:
+            existing_angle = np.angle(bus_data.Vbus[i])
+            if not np.isclose(candidate_Va, existing_angle):
+                logger.add_error(msg='Different control angle set points',
+                                 device=bus_name,
+                                 value=candidate_Va,
+                                 expected_value=existing_angle)
 
 def set_bus_control_voltage_hvdc(i: int,
                                  j: int,
@@ -1757,6 +1823,7 @@ def set_control_dev(k: int,
                     bus_dict: Dict[Bus, int],
                     bus_data: BusData,
                     bus_voltage_used: BoolVec,
+                    bus_angle_used: BoolVec,
                     use_stored_guess: bool,
                     logger: Logger):
     """
@@ -1772,6 +1839,7 @@ def set_control_dev(k: int,
     :param bus_dict: dictionary to be filled in
     :param bus_data: bus data
     :param bus_voltage_used: used bus voltage
+    :param bus_angle_used: used bus angle
     :param use_stored_guess:
     :param logger:
     """
@@ -1806,6 +1874,17 @@ def set_control_dev(k: int,
                                             use_stored_guess=use_stored_guess,
                                             logger=logger)
 
+            elif control == ConverterControlType.Va_ac:
+                set_bus_control_angle_vsc(i=bus_idx,
+                                            j=-1,
+                                            remote_control=False,
+                                            bus_name=str(bus_data.names[bus_idx]),
+                                            bus_angle_used=bus_angle_used,
+                                            bus_data=bus_data,
+                                            candidate_Va=control_val,
+                                            use_stored_guess=use_stored_guess,
+                                            logger=logger)
+
         else:
             # TODO: the formulation does not allow for VSC remote control yet
             # control_branch_idx[k] = branch_dict[control_dev]
@@ -1837,6 +1916,18 @@ def set_control_dev(k: int,
                                         candidate_Vm=control_val,
                                         use_stored_guess=use_stored_guess,
                                         logger=logger)
+        elif control == ConverterControlType.Va_ac:
+            control_bus_idx[k] = t
+
+            set_bus_control_angle_vsc(i=t,
+                                      j=-1,
+                                      remote_control=False,
+                                      bus_name=str(bus_data.names[t]),
+                                      bus_angle_used=bus_angle_used,
+                                      bus_data=bus_data,
+                                      candidate_Va=control_val,
+                                      use_stored_guess=use_stored_guess,
+                                      logger=logger)
 
         else:
             # control_branch_idx[k] = len(branch_dict) + k  # TODO: why?
@@ -1873,7 +1964,7 @@ def get_vsc_data(
     :param logger: Logger
     :return: VscData
     """
-
+    bus_angle_used = bus_data.bus_types == BusMode.Slack_tpe.value
     ii = 0
 
     # VSC
@@ -1914,6 +2005,7 @@ def get_vsc_data(
                             bus_dict=bus_dict,
                             bus_data=bus_data,
                             bus_voltage_used=bus_voltage_used,
+                            bus_angle_used=bus_angle_used,
                             use_stored_guess=use_stored_guess,
                             logger=logger)
             set_control_dev(k=ii, f=f, t=t,
@@ -1925,6 +2017,7 @@ def get_vsc_data(
                             bus_dict=bus_dict,
                             bus_data=bus_data,
                             bus_voltage_used=bus_voltage_used,
+                            bus_angle_used=bus_angle_used,
                             use_stored_guess=use_stored_guess,
                             logger=logger)
 
@@ -1949,6 +2042,7 @@ def get_vsc_data(
                             bus_dict=bus_dict,
                             bus_data=bus_data,
                             bus_voltage_used=bus_voltage_used,
+                            bus_angle_used=bus_angle_used,
                             use_stored_guess=use_stored_guess,
                             logger=logger)
 
@@ -1961,6 +2055,7 @@ def get_vsc_data(
                             bus_dict=bus_dict,
                             bus_data=bus_data,
                             bus_voltage_used=bus_voltage_used,
+                            bus_angle_used=bus_angle_used,
                             use_stored_guess=use_stored_guess,
                             logger=logger)
 

{veragridengine-5.4.6 → veragridengine-5.4.7}/VeraGridEngine/Devices/Branches/vsc.py

@@ -156,9 +156,31 @@ class VSC(BranchParent):
         #     self._bus_dc_n = None
         #     self._bus_to = None
 
-        self._bus_from = bus_from
+        # the VSC must only connect from an DC to a AC bus
+        # this connectivity sense is done to keep track with the articles that set it
+        # from -> DC
+        # to   -> AC
+        # assert(bus_from.is_dc != bus_to.is_dc)
+        if bus_to is not None and bus_from is not None:
+            # connectivity:
+            # for the later primitives to make sense, the "bus from" must be AC and the "bus to" must be DC
+            if bus_from.is_dc and not bus_to.is_dc:  # this is the correct sense
+                self.bus_from = bus_from
+                self.bus_to = bus_to
+            elif not bus_from.is_dc and bus_to.is_dc:  # opposite sense, revert
+                self.bus_from = bus_to
+                self.bus_to = bus_from
+                print('Corrected the connection direction of the VSC device:', self.name)
+            else:
+                raise Exception('Impossible connecting a VSC device here. '
+                                'VSC devices must be connected between AC and DC buses')
+        else:
+            self.bus_from = None
+            self.bus_to = None
+
+        # self._bus_from = bus_from
         self._bus_dc_n = bus_dc_n
-        self._bus_to = bus_to
+        # self._bus_to = bus_to
 
         self.kdp = float(kdp)
         self.alpha1 = float(alpha1)

{veragridengine-5.4.6 → veragridengine-5.4.7}/VeraGridEngine/Devices/multi_circuit.py

@@ -23,7 +23,7 @@ import VeraGridEngine.Devices as dev
 from VeraGridEngine.Devices.types import ALL_DEV_TYPES, INJECTION_DEVICE_TYPES, FLUID_TYPES, AREA_TYPES
 from VeraGridEngine.basic_structures import Logger
 from VeraGridEngine.Topology.topology import find_different_states
-from VeraGridEngine.enumerations import DeviceType, ActionType, SubObjectType, DynamicVarType
+from VeraGridEngine.enumerations import DeviceType, ActionType, SubObjectType, ConverterControlType
 
 
 if TYPE_CHECKING:
@@ -656,6 +656,74 @@ class MultiCircuit(Assets):
 
         return line
 
+    def convert_hvdc_line_to_vsc_system(self, hvdc_line: dev.HvdcLine):
+        """
+        Convert a HvdcLine to the corresponding VSC-DcLine-VSC system
+        :param hvdc_line: HvdcLine
+        :return: ac_bus_1, ac_bus_2, dc_bus_1, dc_bus_2, conv1, conv2, dc_line
+        """
+        ac_bus_1 = hvdc_line.bus_from
+        ac_bus_2 = hvdc_line.bus_to
+
+        dc_bus_1 = dev.Bus(name=ac_bus_1.name + " DC",
+                           Vnom=hvdc_line.dc_link_voltage,
+                           is_dc=True,
+                           latitude=ac_bus_1.latitude,
+                           longitude=ac_bus_1.longitude,
+                           area=ac_bus_1.area,
+                           zone=ac_bus_1.zone,
+                           substation=ac_bus_1.substation,
+                           voltage_level=ac_bus_1.voltage_level,
+                           country=ac_bus_1.country)
+
+        dc_bus_2 = dev.Bus(name=ac_bus_2.name + " DC",
+                           Vnom=hvdc_line.dc_link_voltage,
+                           is_dc=True,
+                           latitude=ac_bus_2.latitude,
+                           longitude=ac_bus_2.longitude,
+                           area=ac_bus_2.area,
+                           zone=ac_bus_2.zone,
+                           substation=ac_bus_2.substation,
+                           voltage_level=ac_bus_2.voltage_level,
+                           country=ac_bus_2.country)
+
+        conv1 = dev.VSC(name=hvdc_line.name + " converter from",
+                        bus_from=dc_bus_1,
+                        bus_to=ac_bus_1,
+                        rate=hvdc_line.rate,
+                        control1=ConverterControlType.Pdc,
+                        control2=ConverterControlType.Vm_ac,
+                        control1_val=hvdc_line.Pset,
+                        control2_val=hvdc_line.Vset_f)
+
+        conv2 = dev.VSC(name=hvdc_line.name + " converter to",
+                        bus_from=dc_bus_2,
+                        bus_to=ac_bus_2,
+                        rate=hvdc_line.rate,
+                        control1=ConverterControlType.Vm_dc,
+                        control2=ConverterControlType.Vm_ac,
+                        control1_val=hvdc_line.Vset_t,
+                        control2_val=hvdc_line.Vset_t)
+
+        Ibase = self.Sbase / hvdc_line.dc_link_voltage
+        Zbase = hvdc_line.dc_link_voltage / Ibase
+
+        dc_line = dev.DcLine(name=hvdc_line.name,
+                             bus_from=dc_bus_1,
+                             bus_to=dc_bus_2,
+                             rate=hvdc_line.rate,
+                             r=hvdc_line.r / Zbase)
+
+        self.add_bus(dc_bus_1)
+        self.add_bus(dc_bus_2)
+        self.add_vsc(conv1)
+        self.add_vsc(conv2)
+        self.add_dc_line(dc_line)
+
+        self.delete_hvdc_line(hvdc_line)
+
+        return ac_bus_1, ac_bus_2, dc_bus_1, dc_bus_2, conv1, conv2, dc_line
+
     def plot_graph(self, ax=None):
         """
         Plot the grid.

{veragridengine-5.4.6 → veragridengine-5.4.7}/VeraGridEngine/IO/epc/epc_parser.py

@@ -213,7 +213,7 @@ def parse_buses(data_lst: List[List], substations_dict: Dict[int, dev.Substation
             area = None
 
         if area_dict is not None:
-            zone_idx = raw[9]  # or maybe 28
+            zone_idx = raw[10]  # or maybe 28
             zone = zone_dict[zone_idx]
         else:
             zone = None

{veragridengine-5.4.6 → veragridengine-5.4.7}/VeraGridEngine/Simulations/InvestmentsEvaluation/investments_evaluation_options.py

@@ -11,7 +11,6 @@ from typing import Union
 from VeraGridEngine.enumerations import SolverType
 
 
-
 class InvestmentsEvaluationOptions(OptionsTemplate):
     """
     Investments Evaluation Options
@@ -22,7 +21,7 @@ class InvestmentsEvaluationOptions(OptionsTemplate):
                  opf_options: Union[OptimalPowerFlowOptions, None] = None,
                  solver: InvestmentEvaluationMethod = InvestmentEvaluationMethod.NSGA3,
                  obj_tpe: InvestmentsEvaluationObjectives = InvestmentsEvaluationObjectives.PowerFlow,
-                 plugin_fcn_ptr: Callable = None,):
+                 plugin_fcn_ptr: Callable = None):
         """
 
         :param max_eval: Maximum number of evaluations
@@ -37,7 +36,8 @@ class InvestmentsEvaluationOptions(OptionsTemplate):
 
         self.pf_options: PowerFlowOptions = pf_options if pf_options else PowerFlowOptions()
 
-        self.opf_options: OptimalPowerFlowOptions = opf_options if opf_options else OptimalPowerFlowOptions(solver=SolverType.NONLINEAR_OPF)
+        self.opf_options: OptimalPowerFlowOptions = opf_options if opf_options else OptimalPowerFlowOptions(
+            solver=SolverType.NONLINEAR_OPF)
 
         self.solver = solver
 
@@ -50,4 +50,3 @@ class InvestmentsEvaluationOptions(OptionsTemplate):
         self.register(key="opf_options", tpe=DeviceType.SimulationOptionsDevice)
         self.register(key="solver", tpe=InvestmentEvaluationMethod)
         self.register(key="objf_tpe", tpe=InvestmentsEvaluationObjectives)
-

{veragridengine-5.4.6 → veragridengine-5.4.7}/VeraGridEngine/Simulations/NTC/ntc_opf.py

@@ -1970,6 +1970,16 @@ def add_linear_vsc_formulation(t_idx: int,
                     name=join("vsc_flow_", [t_idx, m], "_")
                 )
 
+            elif (vsc_data_t.control1[m] == ConverterControlType.Pdc and
+                  vsc_data_t.control2[m] == ConverterControlType.Vm_ac):
+
+                # declare the flow var
+                vsc_vars.flows[t_idx, m] = prob.add_var(
+                    lb=-vsc_data_t.rates[m] / Sbase,
+                    ub=vsc_data_t.rates[m] / Sbase,
+                    name=join("vsc_flow_", [t_idx, m], "_")
+                )
+
             elif (vsc_data_t.control1[m] == ConverterControlType.Pac and
                   vsc_data_t.control2[m] == ConverterControlType.Vm_dc):
 
@@ -1987,6 +1997,16 @@ def add_linear_vsc_formulation(t_idx: int,
                     name=join("vsc_flow_", [t_idx, m], "_")
                 )
 
+            elif (vsc_data_t.control1[m] == ConverterControlType.Vm_dc and
+                  vsc_data_t.control2[m] == ConverterControlType.Vm_ac):
+
+                # set the DC slack
+                val = vsc_data_t.control1_val[m]
+                if val == 0:
+                    val = 1
+                prob.set_var_bounds(var=bus_vars.Vm[t_idx, fr], lb=val, ub=val)
+                any_dc_slack = True
+
             elif (vsc_data_t.control1[m] == ConverterControlType.Vm_dc and
                   vsc_data_t.control2[m] == ConverterControlType.Pdc):
 

{veragridengine-5.4.6 → veragridengine-5.4.7}/VeraGridEngine/Simulations/OPF/Formulations/linear_opf_ts.py

@@ -85,6 +85,7 @@ class BusVars:
         self.Va = np.zeros((nt, n_elm), dtype=object)
         self.Vm = np.ones((nt, n_elm), dtype=object)
         self.Pinj = np.zeros((nt, n_elm), dtype=object)
+        self.Pgen = np.zeros((nt, n_elm), dtype=object)
         self.Pbalance = np.zeros((nt, n_elm), dtype=object)
         self.kirchhoff = np.zeros((nt, n_elm), dtype=object)
         self.shadow_prices = np.zeros((nt, n_elm), dtype=float)
@@ -105,6 +106,7 @@ class BusVars:
                 data.Va[t, i] = model.get_value(self.Va[t, i])
                 data.Vm[t, i] = model.get_value(self.Vm[t, i])
                 data.Pinj[t, i] = model.get_value(self.Pinj[t, i])
+                data.Pgen[t, i] = model.get_value(self.Pgen[t, i])
                 data.Pbalance[t, i] = model.get_value(self.Pbalance[t, i]) * Sbase
                 data.shadow_prices[t, i] = model.get_dual_value(self.kirchhoff[t, i])
 
@@ -923,6 +925,9 @@ def add_linear_generation_formulation(t: Union[int, None],
             # add to the balance
             bus_vars.Pbalance[t, bus_idx] += gen_vars.p[t, k]
 
+            # add to the generation injections in case of inter-area
+            bus_vars.Pgen[t, bus_idx] += gen_vars.p[t, k]
+
         else:
             # the generator is not available at time step
             gen_vars.p[t, k] = 0.0  # there has not been any variable assigned to p[t, k] at this point
@@ -1111,6 +1116,9 @@ def add_linear_battery_formulation(t: Union[int, None],
             # add to the balance
             bus_vars.Pbalance[t, bus_idx] += batt_vars.p[t, k]
 
+            # add to the generation injections in case of inter-area
+            bus_vars.Pgen[t, bus_idx] += batt_vars.p[t, k]
+
         else:
             # the generator is not available at a time step
             batt_vars.p[t, k] = 0.0
@@ -1200,6 +1208,9 @@ def add_linear_load_formulation(t: Union[int, None],
             # add to the balance
             bus_vars.Pbalance[t, bus_idx] -= load_vars.p[t, k]
 
+            # add to the injections
+            # bus_vars.Pinj[t, bus_idx] -= load_vars.p[t, k]
+
         else:
             # the load is not available at time step
             load_vars.shedding[t, k] = 0.0
@@ -2061,10 +2072,21 @@ def run_linear_opf_ts(grid: MultiCircuit,
             # add inter area branch flow maximization ------------------------------------------------------------------
             if maximize_inter_area_flow:
 
-                for branches_list in [inter_area_branches, inter_area_hvdc]:
-                    for k, branch, sense in branches_list:
-                        # we want to maximize, hence the minus sign
-                        f_obj += mip_vars.branch_vars.flows[local_t_idx, k] * (- sense)
+                # maximize the power at the from buses
+                for i in inter_aggregation_info.idx_bus_from:
+                    f_obj -= mip_vars.bus_vars.Pgen[local_t_idx, i]
+
+                # minimize the power at the to buses
+                for i in inter_aggregation_info.idx_bus_to:
+                    f_obj += mip_vars.bus_vars.Pgen[local_t_idx, i]
+
+                for k, branch, sense in inter_area_branches:
+                    # we want to maximize, hence the minus sign
+                    f_obj += mip_vars.branch_vars.flows[local_t_idx, k] * (- sense)
+
+                for k, branch, sense in inter_area_hvdc:
+                    # we want to maximize, hence the minus sign
+                    f_obj += mip_vars.hvdc_vars.flows[local_t_idx, k] * (- sense)
 
             # add hydro side -------------------------------------------------------------------------------------------
             if local_t_idx == 0 and fluid_level_0 is None:

{veragridengine-5.4.6 → veragridengine-5.4.7}/VeraGridEngine/Simulations/PowerFlow/power_flow_options.py

@@ -20,7 +20,7 @@ class PowerFlowOptions(OptionsTemplate):
                  tolerance: float = 1e-6,
                  max_iter: int = 25,
                  limit_i_vsc: bool = False,
-                 control_q: bool = True,
+                 control_q: bool = False,
                  control_taps_modules: bool = True,
                  control_taps_phase: bool = True,
                  control_remote_voltage: bool = True,

{veragridengine-5.4.6 → veragridengine-5.4.7}/VeraGridEngine/__version__.py

@@ -6,7 +6,7 @@ import datetime
 _current_year_ = datetime.datetime.now().year
 
 # remember to keep a three-number version!!!
-__VeraGridEngine_VERSION__ = "5.4.6"
+__VeraGridEngine_VERSION__ = "5.4.7"
 
 url = 'https://github.com/SanPen/VeraGrid'