VeraGridEngine 5.6.12__tar.gz → 5.6.14__tar.gz

{veragridengine-5.6.12 → veragridengine-5.6.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VeraGridEngine
-Version: 5.6.12
+Version: 5.6.14
 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.12 → veragridengine-5.6.14}/VeraGridEngine/Devices/Substation/bus.py

@@ -24,6 +24,7 @@ class Bus(PhysicalDevice):
     __slots__ = (
         'active',
         '_active_prof',
+        'color',
         'Vnom',
         'Vmin',
         'Vm_cost',
@@ -93,7 +94,8 @@ class Bus(PhysicalDevice):
                  Va0=0,
                  graphic_type: BusGraphicType = BusGraphicType.BusBar,
                  bus_bar: BusBar | None = None,
-                 build_status: BuildStatus = BuildStatus.Commissioned):
+                 build_status: BuildStatus = BuildStatus.Commissioned,
+                 color: str | None = None):
         """
         The Bus object is the container of all the possible devices that can be attached to
         a bus bar or Substation. Such objects can be loads, voltage controlled generators,
@@ -127,6 +129,7 @@ class Bus(PhysicalDevice):
         :param Vm0: initial solution for the voltage module (p.u.)
         :param Va0: initial solution for the voltage angle (rad)
         :param graphic_type: BusGraphicType to represent the bus in the schematic
+        :param color: Bus color mark
         """
 
         PhysicalDevice.__init__(self,
@@ -230,10 +233,11 @@ class Bus(PhysicalDevice):
         self.ph_n: bool = True
         self.is_grounded: bool = True
 
+        self.color = color if color is not None else "#000000"
+
         # The model of the bus is fixed, then it can already be defined here
         self._rms_model: DynamicModelHost = DynamicModelHost()
 
-
         self.register(key='active', units='', tpe=bool, definition='Is the bus active? used to disable the bus.',
                       profile_name='active_prof')
         self.register(key='is_slack', units='', tpe=bool, definition='Force the bus to be of slack type.',
@@ -287,6 +291,8 @@ class Bus(PhysicalDevice):
         self.register(key='is_grounded', units='', tpe=bool, definition='Is this bus neutral grounded?.')
         self.register(key='rms_model', units='', tpe=SubObjectType.DynamicModelHostType,
                       definition='RMS dynamic model', display=False)
+        self.register(key='color', units='', tpe=str, definition='Color to paint the element in the diagram',
+                      is_color=True)
 
     @property
     def rms_model(self) -> DynamicModelHost:

{veragridengine-5.6.12 → veragridengine-5.6.14}/VeraGridEngine/IO/dgs/dgs_to_veragrid.py

@@ -449,112 +449,97 @@ def build_switch_by_cubic_id(staswitchs: List[StaSwitch]) -> Dict[str, StaSwitch
         d[cubic_id] = sw
     return d
 
-
-def convert_dgs_to_switches_by_elements(cubics_by_objid: Dict[str, List[StaCubic]],
-                                        switch_by_cubic_id: Dict[str, StaSwitch],
+def convert_dgs_to_switches_from_elmcoup(elmcoups: List[ElmCoup],
+                                        cubics_by_objid: Dict[str, List[StaCubic]],
                                         bus_by_term_id: Dict[str, dev.Bus],
-                                        tr3_ids: Set[str],
+                                        switch_by_cubic_id: Dict[str, StaSwitch],
                                         logger: Logger) -> List[dev.Switch]:
     """
-    Create one VeraGrid Switch per 2-terminal element (line/trafo/etc.) when both ends have StaSwitch.
-    This function filters out "internal" PowerFactory switches (closed and without type) unless
-    they belong to a 3-Winding Transformer.
+    Create VeraGrid Switch devices from ElmCoup.
 
-    :param cubics_by_objid: Dictionary mapping Element ID -> List of Cubicles
-    :param switch_by_cubic_id: Dictionary mapping Cubic ID -> Switch Object
-    :param bus_by_term_id: Dictionary mapping Terminal ID -> Bus Object
-    :param tr3_ids: Set of IDs belonging to 3-Winding Transformers (to force visibility)
-    :param logger: Logger object
+    :param elmcoups: List of ElmCoup objects from DGS
+    :param cubics_by_objid: Dictionary mapping Element ID -> List of StaCubic cubicles
+    :param bus_by_term_id: Dictionary mapping ElmTerm.ID -> VeraGrid Bus
+    :param switch_by_cubic_id: Dictionary mapping StaCubic.ID -> StaSwitch (via StaSwitch.fold_id)
+    :param logger: Logger instance to report warnings
     :return: List of VeraGrid Switch objects
     """
     switches: List[dev.Switch] = list()
 
-    for obj_id, cubics in cubics_by_objid.items():
-        obj_id_ref: str | None = _ref_id(obj_id)
-        if obj_id_ref is None or obj_id_ref == "":
+    for coup in elmcoups:
+        coup_id: str | None = _ref_id(coup.ID)
+        if coup_id is None or coup_id == "":
             continue
 
-        # Avoid duplicates because cubics_by_objid may contain both raw and ref keys
-        if obj_id != obj_id_ref:
-            continue
+        # Resolve connectivity
+        term_ids_raw: List[str] = get_terminal_ids(element_id=coup_id, cubics_by_objid=cubics_by_objid)
 
-        ends: List[Tuple[dev.Bus, StaSwitch]] = list()
+        # Deduplicate terminals while preserving order
+        term_ids: List[str] = list()
+        for tid in term_ids_raw:
+            if tid not in term_ids:
+                term_ids.append(tid)
 
-        for cb in cubics:
-            cb_id: str | None = _ref_id(cb.ID)
-            if cb_id is None or cb_id == "":
-                continue
-
-            stasw: StaSwitch | None = switch_by_cubic_id.get(cb_id, None)
-            if stasw is None:
-                continue
-
-            term_id: str | None = _ref_id(cb.fold_id)
-            if term_id is None or term_id == "":
-                continue
-
-            bus: dev.Bus = bus_by_term_id[term_id]
-            ends.append((bus, stasw))
-
-        if len(ends) != 2:
+        if len(term_ids) != 2:
+            logger.add_warning(
+                f"ElmCoup '{coup.loc_name}' (ID={coup.ID}) skipped: "
+                f"expected 2 terminals, got {len(term_ids)}."
+            )
             continue
 
-        bus_from: dev.Bus = ends[0][0]
-        bus_to: dev.Bus = ends[1][0]
+        bus_from: dev.Bus = bus_by_term_id[term_ids[0]]
+        bus_to: dev.Bus = bus_by_term_id[term_ids[1]]
 
         # Skip degenerate cases
         if bus_from is bus_to:
+            logger.add_warning(
+                f"ElmCoup '{coup.loc_name}' (ID={coup.ID}) skipped: both ends connect to the same bus."
+            )
             continue
 
-        sw_a: StaSwitch = ends[0][1]
-        sw_b: StaSwitch = ends[1][1]
-
-        # Physical state
-        is_closed: bool = (int(sw_a.on_off) != 0) and (int(sw_b.on_off) != 0)
+        # ElmCoup.on_off is the authoritative electrical state
+        is_closed: bool = (int(coup.on_off) != 0)
 
-        # --- VISIBILITY FILTER ---
-        # 1. Check if switches have a specific Type assigned (Real Device)
-        #    In DGS, an empty type usually means it is a logical connector.
-        has_type_a: bool = (sw_a.typ_id is not None) and (str(sw_a.typ_id).strip() != "")
-        has_type_b: bool = (sw_b.typ_id is not None) and (str(sw_b.typ_id).strip() != "")
-        is_real_device: bool = has_type_a or has_type_b
-
-        # 2. Check if it belongs to a 3-Winding Transformer (User requirement)
-        is_tr3: bool = obj_id_ref in tr3_ids
-
-        # 3. Logic: Show if OPEN or REAL DEVICE or TR3. Hide otherwise.
-        should_render: bool = (not is_closed) or is_real_device or is_tr3
-
-        if not should_render:
-            continue
-        # -------------------------
+        # Validation using StaSwitch on each cubicle
+        # (StaSwitch.on_off may represent a cubicle-end representation, not the physical device state)
+        cubics: List[StaCubic] = cubics_by_objid.get(coup_id, list())
+        for cb in cubics:
+            cb_id: str | None = _ref_id(cb.ID)
+            if cb_id is None or cb_id == "":
+                continue
 
-        # Calculate graphical position (midpoint between buses)
-        mid_x: float = (float(bus_from.x) + float(bus_to.x)) / 2.0
-        mid_y: float = (float(bus_from.y) + float(bus_to.y)) / 2.0
+            stasw: StaSwitch | None = switch_by_cubic_id.get(cb_id, None)
+            if stasw is None:
+                continue
 
-        normal_open: bool = not is_closed
-        graphic_type: SwitchGraphicType = _convert_pf_switch_graphic_type(iuse=sw_a.iUse, ausage=sw_a.aUsage)
+            stasw_closed: bool = (int(stasw.on_off) != 0)
+            if stasw_closed != is_closed:
+                logger.add_warning(
+                    f"ElmCoup '{coup.loc_name}' (ID={coup.ID}) state differs from StaSwitch "
+                    f"'{stasw.loc_name}' (ID={stasw.ID}): "
+                    f"ElmCoup.on_off={int(coup.on_off)} vs StaSwitch.on_off={int(stasw.on_off)}. "
+                    f"Using ElmCoup.on_off as truth."
+                )
 
-        sw = dev.Switch(bus_from=bus_from,
-                        bus_to=bus_to,
-                        name=f"SW_{obj_id_ref}",
-                        idtag=obj_id_ref,
-                        code=sw_a.typ_id,
-                        active=is_closed,
-                        normal_open=normal_open,
-                        retained=False,
-                        rated_current=0.0,
-                        graphic_type=graphic_type,
-                        # x=mid_x,
-                        # y=mid_y
-                        )
+        graphic_type: SwitchGraphicType = _convert_pf_switch_graphic_type(iuse=0, ausage=coup.aUsage)
+
+        sw = dev.Switch(
+            bus_from=bus_from,
+            bus_to=bus_to,
+            name=coup.loc_name or f"ElmCoup_{coup_id}",
+            idtag=coup_id,
+            code=coup.typ_id,
+            active=is_closed,
+            normal_open=not is_closed,
+            retained=False,
+            rated_current=0.0,
+            graphic_type=graphic_type
+        )
 
         switches.append(sw)
 
     return switches
 
-
 def _convert_pf_switch_graphic_type(iuse: int, ausage: str) -> SwitchGraphicType:
     """
     Convert PowerFactory/DGS switch usage fields to a VeraGrid SwitchGraphicType.
@@ -567,6 +552,7 @@ def _convert_pf_switch_graphic_type(iuse: int, ausage: str) -> SwitchGraphicType
     usage_to_member: Dict[str, str] = {
         "CB": "CircuitBreaker",
         "BREAKER": "CircuitBreaker",
+        "CBK": "CircuitBreaker",
         "DIS": "Disconnector",
         "DISCONNECTOR": "Disconnector",
         "LBS": "LoadBreakSwitch",
@@ -1587,28 +1573,19 @@ def dgs_to_circuit(path: str, logger: Logger | None = None) -> dev.MultiCircuit:
         # MultiCircuit supports generic branch insertion
         grid.add_series_reactance(obj=sr)
 
-    # switches (PowerFactory/DGS: StaSwitch.fold_id -> StaCubic.ID -> ElmTerm.ID -> Bus)
+    # switches (PowerFactory/DGS: ElmCoup is the real device; StaCubic resolves connectivity)
     switch_by_cubic_id: Dict[str, StaSwitch] = build_switch_by_cubic_id(staswitchs=dgs_grid.staswitchs)
 
-    # Collect 3-Winding Transformers IDs to force switch visibility
-    tr3_set: Set[str] = set()
-    for elmtr3 in dgs_grid.elmtr3s:
-        tid = _ref_id(elmtr3.ID)
-        if tid is not None and tid != "":
-            tr3_set.add(tid)
-
-    # Convert Switches with visibility filter
-    vg_switches: List[dev.Switch] = convert_dgs_to_switches_by_elements(
+    vg_switches: List[dev.Switch] = convert_dgs_to_switches_from_elmcoup(
+        elmcoups=dgs_grid.elmcoups,
         cubics_by_objid=cubics_by_objid,
-        switch_by_cubic_id=switch_by_cubic_id,
         bus_by_term_id=bus_by_term_id,
-        tr3_ids=tr3_set,
+        switch_by_cubic_id=switch_by_cubic_id,
         logger=logger
     )
 
     for sw in vg_switches:
         grid.add_switch(obj=sw)
-
     # Transformers 2W
     for elmtr2 in dgs_grid.elmtr2s:
         trafo = convert_dgs_to_transformer(
@@ -1662,3 +1639,112 @@ def dgs_to_circuit(path: str, logger: Logger | None = None) -> dev.MultiCircuit:
         grid.add_transformer3w(obj=trafo3w)
 
     return grid
+
+
+"""
+Funcion usada antes para los switches a partir de los StaSwitch. Era erronea, deviamos parsearlos a partir de los ElmCoup:
+def convert_dgs_to_switches_by_elements(cubics_by_objid: Dict[str, List[StaCubic]],
+                                        switch_by_cubic_id: Dict[str, StaSwitch],
+                                        bus_by_term_id: Dict[str, dev.Bus],
+                                        tr3_ids: Set[str],
+                                        logger: Logger) -> List[dev.Switch]:
+    
+    Create one VeraGrid Switch per 2-terminal element (line/trafo/etc.) when both ends have StaSwitch.
+    This function filters out "internal" PowerFactory switches (closed and without type) unless
+    they belong to a 3-Winding Transformer.
+
+    :param cubics_by_objid: Dictionary mapping Element ID -> List of Cubicles
+    :param switch_by_cubic_id: Dictionary mapping Cubic ID -> Switch Object
+    :param bus_by_term_id: Dictionary mapping Terminal ID -> Bus Object
+    :param tr3_ids: Set of IDs belonging to 3-Winding Transformers (to force visibility)
+    :param logger: Logger object
+    :return: List of VeraGrid Switch objects
+   
+    switches: List[dev.Switch] = list()
+
+    for obj_id, cubics in cubics_by_objid.items():
+        obj_id_ref: str | None = _ref_id(obj_id)
+        if obj_id_ref is None or obj_id_ref == "":
+            continue
+
+        # Avoid duplicates because cubics_by_objid may contain both raw and ref keys
+        if obj_id != obj_id_ref:
+            continue
+
+        ends: List[Tuple[dev.Bus, StaSwitch]] = list()
+
+        for cb in cubics:
+            cb_id: str | None = _ref_id(cb.ID)
+            if cb_id is None or cb_id == "":
+                continue
+
+            stasw: StaSwitch | None = switch_by_cubic_id.get(cb_id, None)
+            if stasw is None:
+                continue
+
+            term_id: str | None = _ref_id(cb.fold_id)
+            if term_id is None or term_id == "":
+                continue
+
+            bus: dev.Bus = bus_by_term_id[term_id]
+            ends.append((bus, stasw))
+
+        if len(ends) != 2:
+            continue
+
+        bus_from: dev.Bus = ends[0][0]
+        bus_to: dev.Bus = ends[1][0]
+
+        # Skip degenerate cases
+        if bus_from is bus_to:
+            continue
+
+        sw_a: StaSwitch = ends[0][1]
+        sw_b: StaSwitch = ends[1][1]
+
+        # Physical state
+        is_closed: bool = (int(sw_a.on_off) != 0) and (int(sw_b.on_off) != 0)
+
+        # --- VISIBILITY FILTER ---
+        # 1. Check if switches have a specific Type assigned (Real Device)
+        #    In DGS, an empty type usually means it is a logical connector.
+        has_type_a: bool = (sw_a.typ_id is not None) and (str(sw_a.typ_id).strip() != "")
+        has_type_b: bool = (sw_b.typ_id is not None) and (str(sw_b.typ_id).strip() != "")
+        is_real_device: bool = has_type_a or has_type_b
+
+        # 2. Check if it belongs to a 3-Winding Transformer (User requirement)
+        is_tr3: bool = obj_id_ref in tr3_ids
+
+        # 3. Logic: Show if OPEN or REAL DEVICE or TR3. Hide otherwise.
+        should_render: bool = (not is_closed) or is_real_device or is_tr3
+
+        if not should_render:
+            continue
+        # -------------------------
+
+        # Calculate graphical position (midpoint between buses)
+        mid_x: float = (float(bus_from.x) + float(bus_to.x)) / 2.0
+        mid_y: float = (float(bus_from.y) + float(bus_to.y)) / 2.0
+
+        normal_open: bool = not is_closed
+        graphic_type: SwitchGraphicType = _convert_pf_switch_graphic_type(iuse=sw_a.iUse, ausage=sw_a.aUsage)
+
+        sw = dev.Switch(bus_from=bus_from,
+                        bus_to=bus_to,
+                        name=f"SW_{obj_id_ref}",
+                        idtag=obj_id_ref,
+                        code=sw_a.typ_id,
+                        active=is_closed,
+                        normal_open=normal_open,
+                        retained=False,
+                        rated_current=0.0,
+                        graphic_type=graphic_type,
+                        # x=mid_x,
+                        # y=mid_y
+                        )
+
+        switches.append(sw)
+
+    return switches
+
+"""

{veragridengine-5.6.12 → veragridengine-5.6.14}/VeraGridEngine/IO/ucte/devices/ucte_base.py

@@ -42,20 +42,29 @@ def sub_float(line: str, a: int, b: int, device: str, prop_name: str, logger: Lo
     if len(line) > b:
         chunk = line[a:b].strip()
 
-        try:
-            return float(chunk)
-        except ValueError as e:
-            logger.add_error(msg=str(e),
+        if chunk == "":
+            logger.add_error(msg="Empty chunk",
                              device=device,
                              device_property=prop_name,
-                             value=chunk)
+                             value=line)
             return fallback_value
+        else:
+            try:
+                return float(chunk)
+            except ValueError as e:
+                logger.add_error(msg=str(e),
+                                 device=device,
+                                 device_property=prop_name,
+                                 value=chunk)
+                return fallback_value
     else:
-        logger.add_error(msg=f"Could not parse {prop_name} because the file row is too short",
-                         device=device,
-                         device_property=prop_name,
-                         value=line,
-                         expected_value=b)
+        logger.add_warning(msg=f"Could not parse property <{prop_name}> "
+                               f"because the file row is too short, "
+                               f"setting fallback value",
+                           device=device,
+                           device_property=prop_name,
+                           value=line,
+                           expected_value=b)
         return fallback_value
 
 
@@ -95,16 +104,23 @@ def sub_int(line: str, a: int, b: int, device: str, prop_name: str, logger: Logg
     if len(line) > b:
         chunk = line[a:b].strip()
 
-        try:
-            return int(chunk)
-        except ValueError as e:
-            logger.add_error(msg=str(e),
+        if chunk == "":
+            logger.add_error(msg="Empty chunk",
                              device=device,
                              device_property=prop_name,
-                             value=chunk)
+                             value=line)
             return fallback_value
+        else:
+            try:
+                return int(chunk)
+            except ValueError as e:
+                logger.add_error(msg=str(e),
+                                 device=device,
+                                 device_property=prop_name,
+                                 value=chunk)
+                return fallback_value
     else:
-        logger.add_error(msg=f"Could not parse {prop_name} because the file row is too short",
+        logger.add_error(msg=f"Could not parse <{prop_name}> because the file row is too short",
                          device=device,
                          device_property=prop_name,
                          value=line,
@@ -130,7 +146,7 @@ def sub_str(line: str, a: int, b: int, device: str, prop_name: str, logger: Logg
         chunk = line[a:b].strip()
         return chunk
     else:
-        logger.add_error(msg=f"Could not parse {prop_name} because the file row is too short",
+        logger.add_error(msg=f"Could not parse <{prop_name}> because the file row is too short",
                          device=device,
                          device_property=prop_name,
                          value=line,

{veragridengine-5.6.12 → veragridengine-5.6.14}/VeraGridEngine/IO/ucte/devices/ucte_circuit.py

@@ -69,6 +69,9 @@ class UcteCircuit:
                                 current_block = "comments"
                             elif line.startswith("##N"):
                                 current_block = "nodes"
+                            elif line.startswith("##Z"):
+                                current_block = "nodes"
+                                current_country = line[3:] if line[2] == "Z" else line[2:]  # line[-3:-1]
                             elif line.startswith("##L"):
                                 current_block = "lines"
                             elif line.startswith("##T"):
@@ -82,9 +85,6 @@ class UcteCircuit:
                             else:
                                 pass
 
-                            if line.startswith("##Z"):
-                                current_country = line[-3:-1]
-
                         else:
                             if current_block == "comments":
                                 comment = UcteComment()

{veragridengine-5.6.12 → veragridengine-5.6.14}/VeraGridEngine/IO/ucte/devices/ucte_line.py

@@ -62,7 +62,7 @@ class UcteLine:
 
         device = "Line"
         if len(line) == 66:
-            # cannonical parsing
+            # canonical parsing
             self.node1 = sub_str(line, 0, 8, device, "node1", logger)
             self.node2 = sub_str(line, 9, 17, device, "node2", logger)
             self.order_code = sub_str(line, 18, 19, device, "", logger)
@@ -102,7 +102,7 @@ class UcteLine:
                 self.reactance = try_float(chunks[5].strip(), device, "reactance", logger)
                 self.susceptance = try_float(chunks[6].strip(), device, "susceptance", logger)
                 self.current_limit = try_float(chunks[7].strip(), device, "current_limit", logger, 9999.0)
-                self.name = "No name provided"
+                self.name = f"{self.node1}_{self.node2}_{self.order_code}"
 
                 logger.add_warning("Incorrect number of parameters",
                                    device_class=device,
@@ -117,3 +117,5 @@ class UcteLine:
 
         if self.current_limit < 0:
             self.current_limit = 9999.0
+
+

{veragridengine-5.6.12 → veragridengine-5.6.14}/VeraGridEngine/IO/ucte/devices/ucte_transformer.py

@@ -150,7 +150,7 @@ class UcteTransformer:
                                    expected_value=13)
 
             else:
-                logger.add_error("Incorrect number of parameters",
+                logger.add_error("Completely incorrect number of parameters",
                                  device_class=device,
                                  value=len(chunks),
                                  expected_value=13)

{veragridengine-5.6.12 → veragridengine-5.6.14}/VeraGridEngine/IO/ucte/ucte_to_veragrid.py

@@ -268,3 +268,15 @@ def convert_ucte_to_veragrid(ucte_grid: UcteCircuit, logger: Logger) -> MultiCir
     parse_exchange_power(ucte_grid=ucte_grid, grid=grid, bus_dict=bus_dict, logger=logger)
 
     return grid
+
+
+if __name__ == "__main__":
+    # fname = "/Users/santi/Git/eRoots/VeraGrid/src/tests/data/grids/ucte/12_node_network.uct"
+    fname = "/Users/santi/Git/eRoots/VeraGrid/src/tests/data/grids/ucte/tapPositionsRange.uct"
+
+    logger = Logger()
+    g = UcteCircuit()
+    g.parse_file([fname], logger)
+    parser = convert_ucte_to_veragrid(g, logger)
+
+    print()

{veragridengine-5.6.12 → veragridengine-5.6.14}/VeraGridEngine/Simulations/PowerFlow/NumericalMethods/iwamoto_newton_raphson.py

@@ -147,6 +147,7 @@ def IwamotoNR(nc: NumericalCircuit,
                                                    loading=np.zeros(nc.nbr, dtype=complex),
                                                    losses=np.zeros(nc.nbr, dtype=complex),
                                                    Pfp_vsc=np.zeros(nc.nvsc, dtype=float),
+                                                   Pfn_vsc=np.zeros(nc.nvsc, dtype=float),
                                                    St_vsc=np.zeros(nc.nvsc, dtype=complex),
                                                    If_vsc=np.zeros(nc.nvsc, dtype=float),
                                                    It_vsc=np.zeros(nc.nvsc, dtype=complex),

{veragridengine-5.6.12 → veragridengine-5.6.14}/VeraGridEngine/Simulations/PowerFlow/NumericalMethods/linearized_power_flow.py

@@ -408,6 +408,7 @@ def lacpf(nc: NumericalCircuit,
                                            loading=np.zeros(nc.nbr, dtype=complex),
                                            losses=np.zeros(nc.nbr, dtype=complex),
                                            Pfp_vsc=np.zeros(nc.nvsc, dtype=float),
+                                           Pfn_vsc=np.zeros(nc.nvsc, dtype=float),
                                            St_vsc=np.zeros(nc.nvsc, dtype=complex),
                                            If_vsc=np.zeros(nc.nvsc, dtype=float),
                                            It_vsc=np.zeros(nc.nvsc, dtype=complex),

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