VeraGridEngine 5.6.7__tar.gz → 5.6.9__tar.gz

{veragridengine-5.6.7 → veragridengine-5.6.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VeraGridEngine
-Version: 5.6.7
+Version: 5.6.9
 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.6.7 → veragridengine-5.6.9}/VeraGridEngine/Devices/Diagrams/base_diagram.py

@@ -446,6 +446,20 @@ class BaseDiagram:
                 node_devices.append(location.api_object)
                 node_count += 1
 
+        # Add 3W-transformers ------------------------------------------------------------------------------------------
+        tr3_groups = self.data.get(DeviceType.Transformer3WDevice.value, None)
+        if tr3_groups:
+            for i, (idtag, location) in enumerate(tr3_groups.locations.items()):
+                graph.add_node(node_count)
+                graph_node_dictionary[idtag] = node_count
+
+                if location.api_object.bus0 is not None:
+                    # the electrical bus location is the same
+                    graph_node_dictionary[location.api_object.bus0.idtag] = node_count
+
+                node_devices.append(location.api_object)
+                node_count += 1
+
         # Add the electrical branches ----------------------------------------------------------------------------------
         tuples = list()
         for dev_type in [DeviceType.LineDevice,

{veragridengine-5.6.7 → veragridengine-5.6.9}/VeraGridEngine/IO/dgs/dgs_parser.py

@@ -5,6 +5,7 @@
 
 from typing import Dict, Tuple, List
 from VeraGridEngine.Devices.multi_circuit import MultiCircuit
+from VeraGridEngine.enumerations import ConverterControlType
 import VeraGridEngine.Devices as dev
 import math
 import numpy as np
@@ -171,6 +172,7 @@ def read_DGS(filename):
                 chnks = ["0" if x == "" else x for x in chnks]
                 data[current_type].append(np.array(tuple(chnks)))
 
+    '''
     # format keys
     for key in data.keys():
         header = Headers[key]
@@ -185,6 +187,42 @@ def read_DGS(filename):
             else:
                 pass
         data[key] = df
+    '''
+    for key in data.keys():
+        header = Headers[key]
+        rows = data[key]
+
+        fixed_rows = []
+        n_cols = len(header)
+
+        for row in rows:
+
+            # --- skip empty rows safely ---
+            if row is None or len(row) == 0:
+                continue
+
+            # convert np.array rows to list (safe)
+            if not isinstance(row, list):
+                row = list(row)
+
+            if len(row) > n_cols:
+                row = row[:n_cols]
+
+            elif len(row) < n_cols:
+                row = row + [None] * (n_cols - len(row))
+
+            fixed_rows.append(row)
+
+        df = pd.DataFrame(fixed_rows, columns=header)
+
+        # parse numbers with commas
+        for col_name, tpe in types_dict2[key]:
+            if tpe == float:
+                df[col_name] = df[col_name].astype(str).str.replace(',', '.').astype(float)
+            elif tpe == int:
+                df[col_name] = df[col_name].astype(str).str.replace(',', '.').astype(int)
+
+        data[key] = df
 
     # positions dictionary
     obj_id = data['IntGrf']['pDataObj'].values
@@ -199,7 +237,8 @@ def read_DGS(filename):
 
 def data_to_grid_object(data: Dict[str, pd.DataFrame],
                         pos_dict: Dict[str, Tuple[float, float]],
-                        codification: str = "utf-8") -> MultiCircuit:
+                        codification: str = "utf-8",
+                        options: str = "statgen") -> MultiCircuit:
     """
     Turns the read data dictionary into a VeraGrid MultiCircuit object
     Args:
@@ -632,7 +671,10 @@ def data_to_grid_object(data: Dict[str, pd.DataFrame],
 
     for i in range(len(buses)):
         ID = int(id_arr[i])
-        x, y = pos_dict[ID]
+        if str(ID) in pos_dict:
+            x, y = pos_dict[str(ID)]
+        else:
+            x, y = 0.0, 0.0
         buses_dict[ID] = i
         bus_name = buses['loc_name'][i] # .decode(codification)  # BUS_Name
         vnom = buses['uknom'][i]
@@ -733,9 +775,17 @@ def data_to_grid_object(data: Dict[str, pd.DataFrame],
     # print('Parsing lines')
 
     if lines_types.__len__() > 0:
-        lines_ID = lines['ID'].values
+
+        if "ID" in lines:
+            lines_ID = lines['ID'].values
+            line_types_ID = lines_types['ID'].values
+        elif "FID" in lines:
+            lines_ID = lines['FID'].values
+            line_types_ID = lines_types['FID'].values
+        else:
+            raise ValueError("No line ID, FID could be found...")
+
         lines_type_id = lines['typ_id'].values
-        line_types_ID = lines_types['ID'].values
         lines_lenght = lines['dline'].values
 
         if 'outserv' in lines.keys():
@@ -745,9 +795,17 @@ def data_to_grid_object(data: Dict[str, pd.DataFrame],
 
         lines_R = lines_types['rline'].values
         lines_L = lines_types['xline'].values
-        lines_C = lines_types['cline'].values
+
+        lines_C = None
+        lines_B = None
+        if 'cline' in lines_types:
+            lines_C = lines_types['cline'].values
+        elif 'bline' in lines_types:
+            lines_B = lines_types['bline'].values
+
         lines_rate = lines_types['sline'].values
         lines_voltage = lines_types['uline'].values
+
         for i in range(len(lines)):
             # line_ = branch_line.copy()
 
@@ -756,8 +814,8 @@ def data_to_grid_object(data: Dict[str, pd.DataFrame],
             type_idx = np.where(line_types_ID == ID_Type)[0][0]
 
             buses = terminals_dict[ID]  # array with the ID of the connection Buses
-            bus1 = buses_dict[buses[0]]
-            bus2 = buses_dict[buses[1]]
+            bus1 = buses_dict[int(buses[0])]
+            bus2 = buses_dict[int(buses[1])]
 
             bus_from = circuit.buses[bus1]
             bus_to = circuit.buses[bus2]
@@ -768,7 +826,10 @@ def data_to_grid_object(data: Dict[str, pd.DataFrame],
             lenght = np.double(lines_lenght[i])
             R = np.double(lines_R[type_idx]) * lenght  # Ohm
             L = np.double(lines_L[type_idx]) * lenght  # Ohm
-            C = np.double(lines_C[type_idx]) * lenght * w * 1e-6  # S (siemens)
+            if lines_C is not None:
+                B = np.double(lines_C[type_idx]) * lenght * w * 1e-6  # S (siemens)
+            elif lines_B is not None:
+                B = np.double(lines_B[type_idx]) * lenght * 1e-6  # S (siemens)
 
             # pass impedance to per unit
             vbase = np.double(lines_voltage[type_idx])  # kV
@@ -776,14 +837,14 @@ def data_to_grid_object(data: Dict[str, pd.DataFrame],
             ybase = 1.0 / zbase  # S
             r = R / zbase  # pu
             l = L / zbase  # pu
-            b = C / ybase  # pu
+            b = B / ybase  # pu
 
             # rated power
             Irated = np.double(lines_rate[type_idx])  # kA
             Smax = Irated * vbase  # MVA
 
             line = dev.Line(bus_from=bus_from, bus_to=bus_to,
-                            name=lines['loc_name'][i].decode(codification),
+                            name=lines['loc_name'][i],
                             r=r,
                             x=l,
                             b=b,
@@ -863,7 +924,13 @@ def data_to_grid_object(data: Dict[str, pd.DataFrame],
         *  chr_name: Characteristic Name
         ********************************************************************************
         """
-        type_ID = transformers_types['ID'].values
+        if "ID" in transformers:
+            type_ID = transformers_types['ID'].values
+        elif "FID" in transformers:
+            type_ID = transformers_types['FID'].values
+        else:
+            raise ValueError("No transformer ID, FID could be found...")
+
         HV_nominal_voltage = transformers_types['utrn_h'].values
         LV_nominal_voltage = transformers_types['utrn_l'].values
         Nominal_power = transformers_types['strn'].values
@@ -871,20 +938,21 @@ def data_to_grid_object(data: Dict[str, pd.DataFrame],
         Iron_losses = transformers_types['pfe'].values
         No_load_current = transformers_types['curmg'].values
         Short_circuit_voltage = transformers_types['uktr'].values
-        # GR_hv1 = transformers_types['ID']
-        # GX_hv1 = transformers_types['ID']
+
         for i in range(len(transformers)):
 
-            # line_ = branch_line.copy()
+            if "ID" in transformers:
+                ID = transformers['ID'][i]
+            elif "FID" in transformers:
+                ID = transformers['FID'][i]
 
-            ID = transformers['ID'][i]
             ID_Type = transformers['typ_id'][i]
 
             if ID_Type in type_ID:
                 type_idx = np.where(type_ID == ID_Type)[0][0]
                 buses = terminals_dict[ID]  # array with the ID of the connection Buses
-                bus1 = buses_dict[buses[0]]
-                bus2 = buses_dict[buses[1]]
+                bus1 = buses_dict[int(buses[0])]
+                bus2 = buses_dict[int(buses[1])]
 
                 bus_from = circuit.buses[bus1]
                 bus_to = circuit.buses[bus2]
@@ -915,7 +983,7 @@ def data_to_grid_object(data: Dict[str, pd.DataFrame],
 
                 trafo = dev.Transformer2W(bus_from=bus_from,
                                           bus_to=bus_to,
-                                          name=transformers['loc_name'][i].decode(codification),
+                                          name=transformers['loc_name'][i],
                                           r=Zs.real,
                                           x=Zs.imag,
                                           g=Ysh.real,
@@ -953,18 +1021,26 @@ def data_to_grid_object(data: Dict[str, pd.DataFrame],
     """
     # print('Parsing Loads')
     if len(loads) > 0:
-        loads_ID = loads['ID']
+
+        if "ID" in loads:
+            loads_ID = loads['ID']
+        elif "FID" in loads:
+            loads_ID = loads['FID']
+        else:
+            raise ValueError("No load ID or FID could be found...")
+
         loads_P = loads['plini']
         loads_Q = loads['qlini']
         scale = loads['scale0']
+
         for i in range(len(loads)):
             ID = loads_ID[i]
-            bus_idx = buses_dict[(terminals_dict[ID][0])]
+            bus_idx = buses_dict[int(terminals_dict[ID][0])]
             bus_obj = circuit.buses[bus_idx]
             p = loads_P[i] * scale[i]  # in MW
             q = loads_Q[i] * scale[i]  # in MVA
 
-            load = dev.Load(name=loads['loc_name'][i].decode(codification),
+            load = dev.Load(name=loads['loc_name'][i],
                             P=p,
                             Q=q)
 
@@ -995,18 +1071,34 @@ def data_to_grid_object(data: Dict[str, pd.DataFrame],
     ********************************************************************************
     '''
     for i in range(len(shunts)):
-        ID = shunts['ID'][i]
+
+        if "ID" in loads:
+            ID = shunts['ID'][i]
+        elif "FID" in loads:
+            ID = shunts['FID'][i]
+        else:
+            raise ValueError("No shunt ID or FID could be found...")
+
         buses = terminals_dict[ID]  # array with the ID of the connection Buses
-        bus1 = buses_dict[buses[0]]
+        bus1 = buses_dict[int(buses[0])]
         bus_obj = circuit.buses[bus1]
-        name = shunts['loc_name'][i].decode(codification)
+        name = shunts['loc_name'][i]
 
+        '''
         if 'qcapn' in shunts.columns.values:
             b = shunts['ushnm'][i] / shunts['qcapn'][i]
         elif 'qtotn' in shunts.columns.values:
             b = shunts['ushnm'][i] / shunts['qtotn'][i]
         else:
             b = 1e-20
+        '''
+
+        if 'qcapn' in shunts.columns.values:
+            b = shunts['qcapn'][i]
+        elif 'qtotn' in shunts.columns.values:
+            b = shunts['qtotn'][i]
+        else:
+            b = 1e-20
 
         shunt = dev.Shunt(name=name, B=b)
         circuit.add_shunt(bus_obj, shunt)
@@ -1033,17 +1125,54 @@ def data_to_grid_object(data: Dict[str, pd.DataFrame],
     ********************************************************************************
     '''
     for i in range(len(static_generators)):
-        ID = static_generators['ID'][i]
+
+        if "ID" in loads:
+            ID = static_generators['ID'][i]
+        elif "FID" in loads:
+            ID = static_generators['FID'][i]
+        else:
+            raise ValueError("No static generator ID or FID could be found...")
+
         buses = terminals_dict[ID]  # array with the ID of the connection Buses
-        bus1 = buses_dict[buses[0]]
+        bus1 = buses_dict[int(buses[0])]
         bus_obj = circuit.buses[bus1]
         mode = static_generators['av_mode'][i]
         num_machines = static_generators['ngnum'][i]
 
-        gen = dev.StaticGenerator(name=static_generators['loc_name'][i].decode(codification),
-                                  P=static_generators['pgini'][i] * num_machines,
-                                  Q=static_generators['qgini'][i] * num_machines)
-        circuit.add_static_generator(bus_obj, gen)
+        if options == "statgen_to_vsc":
+
+            bus_dc = dev.Bus(
+                Vnom = bus_obj.Vnom,
+                xpos = bus_obj.x - 10,
+                ypos = bus_obj.y - 10,
+                is_dc = True,
+                is_slack= True
+            )
+            circuit.add_bus(bus_dc)
+
+            vsc = dev.VSC(
+                bus_from = bus_dc,
+                bus_to = bus_obj,
+                name = bus_obj.name,
+                rate = static_generators['sgn'][i],
+                kdp = 20.0,
+                alpha1=0.0001,
+                alpha2=0.015,
+                alpha3=0.2,
+                control1 = ConverterControlType.Pac,
+                control2 = ConverterControlType.Qac,
+                control1_val = static_generators['pgini'][i] * num_machines,
+                control2_val = static_generators['qgini'][i] * num_machines,
+                control1_dev = None,
+                control2_dev = None,
+            )
+            circuit.add_vsc(vsc)
+
+        else:
+            gen = dev.StaticGenerator(name=static_generators['loc_name'][i],
+                                      P=static_generators['pgini'][i] * num_machines,
+                                      Q=static_generators['qgini'][i] * num_machines)
+            circuit.add_static_generator(bus_obj, gen)
 
     ####################################################################################################################
     # Synchronous Machine (Gen)
@@ -1069,9 +1198,16 @@ def data_to_grid_object(data: Dict[str, pd.DataFrame],
     ********************************************************************************
     '''
     for i in range(len(synchronous_machine)):
-        ID = synchronous_machine['ID'][i]
+
+        if "ID" in loads:
+            ID = synchronous_machine['ID'][i]
+        elif "FID" in loads:
+            ID = synchronous_machine['FID'][i]
+        else:
+            raise ValueError("No synchronous machine ID or FID could be found...")
+
         buses = terminals_dict[ID]  # array with the ID of the connection Buses
-        bus1 = buses_dict[buses[0]]
+        bus1 = buses_dict[int(buses[0])]
         bus_obj = circuit.buses[bus1]
         num_machines = synchronous_machine['ngnum'][i]
 
@@ -1098,7 +1234,7 @@ def data_to_grid_object(data: Dict[str, pd.DataFrame],
 
         snom = typ['sgn'].values[0]
         vnom = synchronous_machine['usetp'][i]
-        name = synchronous_machine['loc_name'][i].decode(codification)
+        name = synchronous_machine['loc_name'][i]
         gen = dev.Generator(name=name,
                             P=synchronous_machine['pgini'][i] * num_machines,
                             vset=vnom,
@@ -1123,4 +1259,4 @@ def dgs_to_circuit(filename: str) -> MultiCircuit:
     """
     data, pos_dict = read_DGS(filename)
 
-    return data_to_grid_object(data, pos_dict)
+    return data_to_grid_object(data, pos_dict, options="statgen_to_vsc")

{veragridengine-5.6.7 → veragridengine-5.6.9}/VeraGridEngine/Simulations/OPF/Formulations/ac_opf_problem.py

@@ -673,8 +673,8 @@ class NonLinearOptimalPfProblem:
         else:
             sl_sf = np.zeros(self.n_br_mon)
             sl_st = np.zeros(self.n_br_mon)
-            sl_vmax = np.zeros(self.nbus)
-            sl_vmin = np.zeros(self.nbus)
+            sl_vmax = np.zeros(self.npq)
+            sl_vmin = np.zeros(self.npq)
 
         if self.options.ips_control_q_limits:  # if reactive power control...
             v_g = self.Vm[self.gen_bus_idx[self.gen_disp_idx]]

{veragridengine-5.6.7 → veragridengine-5.6.9}/VeraGridEngine/Topology/GridReduction/ptdf_grid_reduction.py

@@ -102,7 +102,7 @@ def get_Pload_ts(grid: MultiCircuit) -> Mat:
 def relocate_injections(grid: MultiCircuit,
                         reduction_bus_indices: Sequence[int]):
     """
-    Relocate generators
+    Relocate injection devices (generators, loads, etc.) from external buses to internal buses
     :param grid: MultiCircuit
     :param reduction_bus_indices: array of bus indices to reduce (external set)
     :return: None
@@ -114,11 +114,11 @@ def relocate_injections(grid: MultiCircuit,
     external_gen_data = list()
     internal_set = set()
 
-    # loop through the generators in the external set
+    # loop through all injection devices in the external set
+    # Note: we don't remove from external_set here because multiple devices can be at the same bus
     for k, elm in enumerate(grid.get_injection_devices_iter()):
         i = bus_idx_dict[elm.bus]
         if i in external_set:
-            external_set.remove(i)
             external_gen_set.add(i)
             external_gen_data.append((k, i, elm, 'injection'))
             G.add_node(i)
@@ -494,6 +494,16 @@ def ptdf_reduction_projected(grid: MultiCircuit,
         logger.add_info(msg="Nothing to keep (null grid as a result)")
         return grid, logger
 
+    # Check if slack bus is being removed
+    original_slack_indices = [i for i, bus in enumerate(grid.buses) if bus.is_slack]
+    external_set = set(e_buses)
+    slack_is_removed = any(idx in external_set for idx in original_slack_indices)
+    
+    # If the slack is being removed, we need to relocate injections from the slack
+    # to boundary buses, so the power is not lost when we delete the slack bus
+    if slack_is_removed:
+        relocate_injections(grid=grid, reduction_bus_indices=reduction_bus_indices)
+
     nc = compile_numerical_circuit_at(circuit=grid, t_idx=None)
     lin = LinearAnalysis(nc=nc, distributed_slack=distribute_slack)
 
@@ -539,6 +549,27 @@ def ptdf_reduction_projected(grid: MultiCircuit,
     # Eliminate the external buses (but not relocating injections)
     # We rely on solving for the necessary compensation on the boundary buses
     grid.delete_buses(lst=[grid.buses[e] for e in e_buses], delete_associated=True)
+    
+    # If the slack was removed, assign a new slack bus
+    if slack_is_removed:
+        # Find the best candidate for the new slack among boundary buses
+        # Prefer a boundary bus that has a generator
+        new_slack_assigned = False
+        bus_idx_dict_new = grid.get_bus_index_dict()
+        
+        # First try to find a boundary bus with a generator
+        for gen in grid.generators:
+            if gen.bus is not None:
+                gen_bus_idx = bus_idx_dict_new.get(gen.bus, -1)
+                if gen_bus_idx != -1:
+                    # This bus has a generator, make it slack
+                    gen.bus.is_slack = True
+                    new_slack_assigned = True
+                    break
+        
+        # If no generator found, just pick the first remaining bus
+        if not new_slack_assigned and grid.get_bus_number() > 0:
+            grid.buses[0].is_slack = True
 
     # Injections that remain (internal only, since external are gone)
     Pload2 = get_Pload(grid)

{veragridengine-5.6.7 → veragridengine-5.6.9}/VeraGridEngine/Utils/Sparse/sparse_array.py

@@ -91,7 +91,11 @@ class SparseArray:
     @default_value.setter
     def default_value(self, val):
         """
+        Set the default value, updating the map to maintain consistency.
 
+        When the default value changes, we need to:
+        1. Store the old default for positions that were using it (not in map)
+        2. Remove positions from the map that now equal the new default
         :param val:
         :return:
         """
@@ -107,6 +111,27 @@ class SparseArray:
             val2 = val
 
         check_type(dtype=self.dtype, value=val2)
+
+        # If the value is the same, do nothing
+        if val2 == self._default_value:
+            return
+
+        # If the map has entries and we are changing the default, we need to update the map
+        # to maintain consistency
+        if self._size > 0 and len(self._map) < self._size:
+            old_default = self._default_value
+
+            # Add the old default to all positions not currently in the map
+            # These positions implicitly had the old default value
+            for i in range(self._size):
+                if i not in self._map:
+                    self._map[i] = old_default
+
+        # Now remove any entries from the map that equal the new default
+        keys_to_remove = [k for k, v in self._map.items() if v == val2]
+        for k in keys_to_remove:
+            del self._map[k]
+
         self._default_value = val2
 
     def info(self):

{veragridengine-5.6.7 → veragridengine-5.6.9}/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.6.7"
+__VeraGridEngine_VERSION__ = "5.6.9"
 
 url = 'https://github.com/SanPen/VeraGrid'