VeraGridEngine 5.6.11__tar.gz → 5.6.13__tar.gz

{veragridengine-5.6.11 → veragridengine-5.6.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VeraGridEngine
-Version: 5.6.11
+Version: 5.6.13
 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.11 → veragridengine-5.6.13}/VeraGridEngine/Compilers/circuit_to_gslv.py

@@ -2407,7 +2407,7 @@ def translate_gslv_pf_results(grid: MultiCircuit, res: "pg.PowerFlowResults", lo
     results.loading_hvdc = res.loading_hvdc[0, :]
     results.losses_hvdc = res.losses_hvdc[0, :]
 
-    results.Pf_vsc = res.Pf_vsc[0, :]
+    results.Pfp_vsc = res.Pfp_vsc[0, :]
     results.St_vsc = res.St_vsc[0, :]
     results.loading_vsc = res.loading_vsc[0, :]
     results.losses_vsc = res.losses_vsc[0, :]

{veragridengine-5.6.11 → veragridengine-5.6.13}/VeraGridEngine/Devices/Injections/generator.py

@@ -2,7 +2,7 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at https://mozilla.org/MPL/2.0/.  
 # SPDX-License-Identifier: MPL-2.0
-
+from __future__ import annotations
 
 import numpy as np
 import pandas as pd
@@ -343,6 +343,16 @@ class Generator(GeneratorParent):
         """
         return get_at(self.Pf, self.Pf_prof, t)
 
+    def get_Q_at(self, t: int | None) -> float:
+        """
+        :param t:
+        :return:
+        """
+        p = self.get_P_at(t)
+        pf = get_at(self.Pf, self.Pf_prof, t)
+
+        return p * np.sqrt(1.0 / (pf * pf) - 1.0)
+
     @property
     def Vset_prof(self) -> Profile:
         """

{veragridengine-5.6.11 → veragridengine-5.6.13}/VeraGridEngine/Devices/Injections/static_generator.py

@@ -9,11 +9,11 @@ from VeraGridEngine.Devices.Parents.load_parent import LoadParent
 
 
 class StaticGenerator(LoadParent):
-    __slots__ = ()
+    __slots__ = ("_Snom")
 
     def __init__(self, name='StaticGen', idtag=None, code='', P=0.0, Q=0.0, active=True,
                  P1=0.0, P2=0.0, P3=0.0, Q1=0.0, Q2=0.0, Q3=0.0,
-                 mttf=0.0, mttr=0.0, Cost=1200.0,
+                 mttf=0.0, mttr=0.0, Cost=1200.0, Snom=0,
                  capex=0, opex=0, build_status: BuildStatus = BuildStatus.Commissioned):
         """
 
@@ -58,3 +58,25 @@ class StaticGenerator(LoadParent):
                             opex=opex,
                             build_status=build_status,
                             device_type=DeviceType.StaticGeneratorDevice)
+
+        # Nominal power in MVA (also the machine base)
+        self._Snom = float(Snom)
+
+        self.register(key='Snom', units='MVA', tpe=float, definition='Nominal power.')
+
+    @property
+    def Snom(self):
+        """
+        Return the reactive power lower limit
+        :return: value
+        """
+        return self._Snom
+
+    @Snom.setter
+    def Snom(self, val):
+        """
+        Set the generator nominal power
+        if the reactive power curve was generated automatically, then it is refreshed
+        :param val: float value
+        """
+        self._Snom = val

{veragridengine-5.6.11 → veragridengine-5.6.13}/VeraGridEngine/Devices/Parents/branch_parent.py

@@ -497,6 +497,18 @@ class BranchParent(PhysicalDevice):
         else:
             return bus_t_v, bus_f_v
 
+    def get_buses_sorted_by_voltage(self):
+        """
+        Get the sorted buses
+        :return: HV bus, LV bus
+        """
+        bus_f_v = self.bus_from.Vnom
+        bus_t_v = self.bus_to.Vnom
+        if bus_f_v > bus_t_v:
+            return self.bus_from, self.bus_to
+        else:
+            return self.bus_to, self.bus_from
+
     def get_virtual_taps(self) -> Tuple[float, float]:
         """
         Get the branch virtual taps

{veragridengine-5.6.11 → veragridengine-5.6.13}/VeraGridEngine/Devices/Parents/load_parent.py

@@ -370,6 +370,17 @@ class LoadParent(InjectionParent):
         """
         return complex(self.get_Pc_at(t), self.get_Qc_at(t))
 
+    def get_Pf_at(self, t: int | None) -> float:
+        """
+        Get power factor
+        :param t:
+        :return:
+        """
+        p = self.get_P_at(t)
+        q = self.get_Q_at(t)
+        s = np.sqrt(p*p + q*q)
+        return p / s if s > 0.0 else 0.0
+
     def split_sequence_load_in_3_phase(self, share_a=1.0, share_b=1.0, share_c=1.0):
         """
         Initializes the 3-phase properties using the positive sequence ones

{veragridengine-5.6.11 → veragridengine-5.6.13}/VeraGridEngine/Devices/multi_circuit.py

@@ -17,7 +17,6 @@ from scipy.sparse import csc_matrix, lil_matrix
 
 from VeraGridEngine.Devices.assets import Assets
 from VeraGridEngine.Devices.Parents.editable_device import EditableDevice
-from VeraGridEngine.Utils.Symbolic import Var
 from VeraGridEngine.basic_structures import IntVec, Vec, Mat, CxVec, IntMat, CxMat
 
 import VeraGridEngine.Devices as dev
@@ -76,7 +75,7 @@ def get_fused_device_lst(elm_list: List[INJECTION_DEVICE_TYPES], property_names:
             act_final = bool(act_final + elm2.active)  # equivalent to OR
 
             if act_prof_final is not None:
-                act_prof_final = (act_prof_final.toarray() + elm2.active_prof.toarray()).astype(bool)
+                act_prof_final = (act_prof_final + elm2.active_prof.toarray()).astype(bool)
 
         for prop in property_names:  # sum the properties
 
@@ -860,7 +859,7 @@ class MultiCircuit(Assets):
         Get the branch-bus dictionary
         :return: dict[bus] -> list of branches
         """
-        d: Dict[dev.Bus, List[dev.BranchType]] = {b: list() for b in self._buses}
+        d: Dict[dev.Bus, List[BRANCH_TYPES]] = {b: list() for b in self._buses}
 
         for branch_list in self.get_branch_lists(add_vsc=True, add_hvdc=True, add_switch=True):
             for br in branch_list:
@@ -3075,3 +3074,95 @@ class MultiCircuit(Assets):
                 branch_active, branch_F, branch_T,
                 hvdc_active, hvdc_F, hvdc_T,
                 vsc_active, vsc_F, vsc_T)
+
+    def move_behind_converter(self, api_object: INJECTION_DEVICE_TYPES) -> Tuple[dev.Bus, dev.VSC]:
+        """
+
+        :param api_object:
+        :return:
+        """
+        old_bus = api_object.bus
+        new_bus = dev.Bus(
+            name=old_bus.name + "_dc",
+            Vnom=old_bus.Vnom,
+            is_dc=True,
+            xpos=old_bus.x,
+            ypos=old_bus.y + 20,
+        )
+        self.add_bus(obj=new_bus)
+
+        converter = dev.VSC(
+            name=api_object.name,
+            bus_from=new_bus,
+            bus_to=old_bus,
+            control1=ConverterControlType.Vm_dc,
+            control2=ConverterControlType.Qac,
+            control1_val=1.0,
+            rate=9999.0
+        )
+        self.add_vsc(obj=converter)
+
+        if api_object.device_type == DeviceType.LoadDevice:
+            converter.control2_val = api_object.P
+            if self.has_time_series:
+                converter.control2_val_prof = api_object.P_prof.toarray()
+
+        if api_object.device_type == DeviceType.StaticGeneratorDevice:
+            converter.control2_val = -1 * api_object.P
+            if self.has_time_series:
+                converter.control2_val_prof = -1 * api_object.P_prof.toarray()
+
+        # set the API object new bus
+        api_object.bus = new_bus
+
+        return new_bus, converter
+
+    def slice_buses(self, buses: List[dev.Bus]) -> "MultiCircuit":
+        """
+        Get a subset of the grid
+        :param buses: list of buses to slice te grid
+        :return: new MultiCircuit
+        """
+        other = MultiCircuit()
+
+        bus_set = set(buses)
+
+        # add the branches and extend the set of buses
+        for br in self.get_branches_iter(add_vsc=True, add_hvdc=True, add_switch=True):
+
+            if br.bus_from in bus_set:
+                bus_set.add(br.bus_to)
+                other.add_element(br)
+
+            elif br.bus_to in bus_set:
+                bus_set.add(br.bus_from)
+                other.add_element(br)
+
+            else:
+                pass
+
+        # search for voltage levels and substations
+        vl_set = set()
+        se_set = set()
+        for bus in bus_set:
+            other.add_bus(bus)
+
+            if bus.voltage_level is not None:
+                vl_set.add(bus.voltage_level)
+                if bus.substation is not None:
+                    se_set.add(bus.substation)
+
+        # add substations
+        for se in se_set:
+            other.add_substation(se)
+
+        # add voltage level
+        for vl in vl_set:
+            other.add_voltage_level(vl)
+
+        # add injections
+        for inj in self.get_injection_devices_iter():
+            if inj.bus in bus_set:
+                other.add_element(inj)
+
+        return other

veragridengine-5.6.13/VeraGridEngine/IO/dgs/dgs_circuit.py

@@ -0,0 +1,389 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+# SPDX-License-Identifier: MPL-2.0
+from __future__ import annotations
+import sys
+import os
+from pathlib import Path
+from typing import Dict, List, Type, Optional, Tuple
+from VeraGridEngine.IO.dgs.dgs_objects import *
+
+
+def _populate_from_pf_object(pf_obj: DGSElement, dgs_cls: Type[DGSElement]):
+    """
+    Populate a DGSElement subclass from a PowerFactory API object,
+    using the class schema (properties_list).
+    Assumes the DGSElement has an explicit __init__.
+    """
+    elem = dgs_cls()
+
+    for prop in dgs_cls.properties_list:
+        name = prop.name
+        value = pf_obj.name
+        setattr(elem, name, value)
+
+    return elem
+
+
+def parse_header(line: str) -> Tuple[str, Dict[str, int]]:
+    """
+    Parse $$ header line and return property -> index map.
+    """
+    element_type = line[2:].split(";", 1)[0]
+    parts = line.strip().split(';')[1:]  # skip $$ElementType
+    header_map: Dict[str, int] = {}
+
+    for i, name_stub in enumerate(parts):
+        name_stub = parts[i]
+        stubs = name_stub.split("(")
+        prop_name = stubs[0] if len(stubs) > 0 else name_stub
+        header_map[prop_name] = i
+
+    return element_type, header_map
+
+
+class DgsCircuit:
+    """Strongly-typed container for a PowerFactory DGS file."""
+
+    _ELEMENT_CLASSES: List[Type[DGSElement]] = [
+        General,
+        ChaRef,
+        ChaVec,
+        ElmComp,
+        ElmDsl,
+        ElmAsm,
+        ElmCoup,
+        ElmFeeder,
+        ElmGenstat,
+        ElmLne,
+        ElmSind,
+        ElmLnesec,
+        ElmLod,
+        ElmLodlv,
+        ElmLodlvp,
+        ElmNet,
+        ElmShnt,
+        ElmSvs,
+        ElmSind,
+        ElmSite,
+        ElmSubstat,
+        ElmSym,
+        ElmTerm,
+        ElmTr2,
+        ElmTr3,
+        ElmXnet,
+        ElmZone,
+        General,
+        IntFolder,
+        IntGrf,
+        IntGrfcon,
+        IntGrfnet,
+        RelFuse,
+        StaCubic,
+        StaSwitch,
+        TypAsmo,
+        TypFuse,
+        TypLne,
+        TypSind,
+        TypLod,
+        TypSym,
+        TypTr2,
+        TypTr3,
+    ]
+
+    _REGISTRY: Dict[str, Type[DGSElement]] = {cls.element_type: cls for cls in _ELEMENT_CLASSES}
+
+    def __init__(self) -> None:
+        """
+
+        """
+        self._id_counter = 0
+
+        self.generals: List[General] = list()
+        self.elmcomps: List[ElmComp] = list()
+        self.elmdsls: List[ElmDsl] = list()
+        self.charefs: List[ChaRef] = list()
+        self.chavecs: List[ChaVec] = list()
+        self.elmasms: List[ElmAsm] = list()
+        self.elmcoups: List[ElmCoup] = list()
+        self.elmfeeders: List[ElmFeeder] = list()
+        self.elmgenstats: List[ElmGenstat] = list()
+        self.elmlnes: List[ElmLne] = list()
+        self.elmsinds: List[ElmSind] = list()
+        self.elmlnesecs: List[ElmLnesec] = list()
+        self.elmlods: List[ElmLod] = list()
+        self.elmlodlvs: List[ElmLodlv] = list()
+        self.elmlodlvps: List[ElmLodlvp] = list()
+        self.elmnets: List[ElmNet] = list()
+        self.elmshnts: List[ElmShnt] = list()
+        self.elmsvss: List[ElmSvs] = list()
+        self.elmsinds: List[ElmSind] = list()
+        self.elmsites: List[ElmSite] = list()
+        self.elmsubstats: List[ElmSubstat] = list()
+        self.elmsyms: List[ElmSym] = list()
+        self.elmterms: List[ElmTerm] = list()
+        self.elmtr2s: List[ElmTr2] = list()
+        self.elmtr3s: List[ElmTr3] = list()
+        self.elmxnets: List[ElmXnet] = list()
+        self.elmzones: List[ElmZone] = list()
+        self.intfolders: List[IntFolder] = list()
+        self.intgrfs: List[IntGrf] = list()
+        self.intgrfcons: List[IntGrfcon] = list()
+        self.intgrfnets: List[IntGrfnet] = list()
+        self.relfuses: List[RelFuse] = list()
+        self.stacubics: List[StaCubic] = list()
+        self.staswitchs: List[StaSwitch] = list()
+        self.typasmos: List[TypAsmo] = list()
+        self.typfuses: List[TypFuse] = list()
+        self.typlnes: List[TypLne] = list()
+        self.typsinds: List[TypSind] = list()
+        self.typlods: List[TypLod] = list()
+        self.typsyms: List[TypSym] = list()
+        self.typtr2s: List[TypTr2] = list()
+        self.typtr3s: List[TypTr3] = list()
+
+        self._CLASS_TO_LIST: Dict[Type[DGSElement], List[DGSElement]] = {
+            General: self.generals,
+            ChaRef: self.charefs,
+            ChaVec: self.chavecs,
+            ElmComp: self.elmcomps,
+            ElmDsl: self.elmdsls,
+            ElmAsm: self.elmasms,
+            ElmCoup: self.elmcoups,
+            ElmFeeder: self.elmfeeders,
+            ElmGenstat: self.elmgenstats,
+            ElmLne: self.elmlnes,
+            ElmSind: self.elmsinds,
+            ElmLnesec: self.elmlnesecs,
+            ElmLod: self.elmlods,
+            ElmLodlv: self.elmlodlvs,
+            ElmLodlvp: self.elmlodlvps,
+            ElmNet: self.elmnets,
+            ElmShnt: self.elmshnts,
+            ElmSvs: self.elmsvss,
+            ElmSite: self.elmsites,
+            ElmSubstat: self.elmsubstats,
+            ElmSym: self.elmsyms,
+            ElmTerm: self.elmterms,
+            ElmTr2: self.elmtr2s,
+            ElmTr3: self.elmtr3s,
+            ElmXnet: self.elmxnets,
+            ElmZone: self.elmzones,
+            IntFolder: self.intfolders,
+            IntGrf: self.intgrfs,
+            IntGrfcon: self.intgrfcons,
+            IntGrfnet: self.intgrfnets,
+            RelFuse: self.relfuses,
+            StaCubic: self.stacubics,
+            StaSwitch: self.staswitchs,
+            TypAsmo: self.typasmos,
+            TypFuse: self.typfuses,
+            TypLne: self.typlnes,
+            TypSind: self.typsinds,
+            TypLod: self.typlods,
+            TypSym: self.typsyms,
+            TypTr2: self.typtr2s,
+            TypTr3: self.typtr3s,
+        }
+
+    def new_id(self) -> str:
+        """
+
+        :return:
+        """
+        self._id_counter += 1
+        return str(self._id_counter)
+
+    def add_element_cubicles(self, element_id: str, dgs_buses: List[ElmTerm]):
+        """
+        Add cubicles
+        :param element_id: Element ID
+        :param dgs_buses: list of ElmTerm
+        """
+        for i, b in enumerate(dgs_buses):
+            c = StaCubic()
+            c.ID = self.new_id()
+            c.loc_name = f"StaCubic_{c.ID}"
+            c.obj_id = element_id
+            c.obj_bus = i
+            c.fold_id = b.ID
+            self.stacubics.append(c)
+
+    def parse_dgs(self, path: str):
+        """
+        Parse a DGS file and populate the typed lists.
+        """
+        path = Path(path)
+        current_cls: Optional[Type[DGSElement]] = None
+        header_map: Dict[str, int] | None = None
+
+        with path.open("r", encoding="utf-8", errors="ignore") as f:
+            for raw_line in f:
+                line = raw_line.strip()
+
+                if line == "" or line.startswith("*"):
+                    # Empty line or comment
+                    pass
+
+                elif line.startswith("$$"):
+                    # Header line
+                    element_type, header_map = parse_header(line)
+                    current_cls = self._REGISTRY.get(element_type)
+
+                else:
+                    # Data line
+                    if current_cls is not None:
+                        obj = current_cls.parse_line(line=line, header_map=header_map)
+
+                        if obj is not None:
+                            objects_lst = self._CLASS_TO_LIST[current_cls]
+                            objects_lst.append(obj)
+
+    def write_dgs(self, path: str):
+        """
+        Write the circuit back to a DGS file.
+        """
+        path = Path(path)
+
+        with path.open("w", encoding="utf-8") as f:
+
+            comment = "*" * 80 + "\n"
+            comment += "* Created with VeraGrid\n"
+            comment += "*" * 80 + "\n"
+            f.write(comment + "\n")
+
+            for cls in self._ELEMENT_CLASSES:
+                objects: List[DGSElement] = self._CLASS_TO_LIST[cls]
+
+                if len(objects) > 0:
+
+                    header = "$$" + cls.element_type + ";" + ";".join(
+                        f"{p.name}({p.dgs_type})" for p in cls.properties_list
+                    )
+                    f.write(header + "\n")
+
+                    comment = "*" * 80 + "\n"
+                    for prp in objects[0].properties_list:
+                        comment += f"* {prp.name}: {prp.dgs_type}: {prp.description}\n"
+
+                    comment += "*" * 80
+                    f.write(comment + "\n")
+
+                    for obj in objects:
+                        f.write(obj.to_dgs_line() + "\n")
+
+                    f.write("\n")
+
+    def from_api(self, study_case_name: str | None = None, pf_path: str = "") -> None:
+        """
+        Populate this (empty) PfCircuit from an active PowerFactory application.
+        Assumes:
+        - self is empty (no existing elements)
+        - schema registries (_ELEMENT_CLASSES, _CLASS_TO_LIST) are complete
+        :param study_case_name: case name if any
+        :param pf_path: PowerFactory path
+        :return:
+        """
+        if pf_path == "":
+            pf_path = r"C:\Program Files\DIgSILENT\PowerFactory 2025 SP1"
+        os.environ["PATH"] = pf_path + ";" + os.environ["PATH"]
+        python_folder = f"{sys.version_info.major}.{sys.version_info.minor}"
+        module_folder = os.path.join(pf_path, "Python", python_folder)
+
+        if not os.path.exists(module_folder):
+            print(f"PowerFactory path for the compatible module not found: {module_folder}")
+
+        # add the pf path to the system path
+        sys.path.append(pf_path)
+        sys.path.append(module_folder)
+
+        # Obtain PowerFactory application ------------------------------------------------------------------------------
+        try:
+            import powerfactory as pf
+            print(f"loaded PowerFactory version {pf.__version__}")
+        except ImportError as e:
+            print("PowerFactory Python module not available. "
+                  "Ensure this is executed inside a PowerFactory Python environment.", str(e))
+            return None
+
+        try:
+            app = pf.GetApplicationExt()
+        except pf.ExitError as error:
+            print(error)
+            print('error.code = %d' % error.code)
+            return None
+
+        except RuntimeError as e:
+            print("Failed to obtain PowerFactory application. "
+                  "Ensure PowerFactory is running and a project is open.", str(e))
+            return None
+
+        # Activate study case  -----------------------------------------------------------------------------------------
+
+        try:
+            project = app.GetActiveProject()
+        except RuntimeError as e:
+            print("No active PowerFactory project.", str(e))
+            return None
+
+        if project is None:
+            print("No active PowerFactory project.")
+            return None
+
+        # Fetch all study cases
+        try:
+            cases = project.GetContents("*.IntCase", recursive=True)
+        except RuntimeError as e:
+            print("Failed to retrieve study cases.", str(e))
+            return None
+
+        if not cases:
+            print("No study cases found in the project.")
+            return None
+
+        active_case = None
+
+        if study_case_name is not None:
+            for case in cases:
+                if case.loc_name == study_case_name:
+                    active_case = case
+                    break
+
+            if active_case is None:
+                print(f"Study case '{study_case_name}' not found in project.")
+                return None
+
+        else:
+            # Use currently active case, if any
+            try:
+                active_case = app.GetActiveStudyCase()
+            except RuntimeError:
+                active_case = None
+
+            if active_case is None:
+                print("No study case is active. Please specify study_case_name explicitly.")
+                return None
+
+        # Activate selected case
+        try:
+            active_case.Activate()
+        except RuntimeError as e:
+            print(f"Failed to activate study case '{active_case.loc_name}'.", str(e))
+            return None
+
+        # Iterate over all known DGSElement subclasses
+        for dgs_cls in self._ELEMENT_CLASSES:
+            pf_class_name = dgs_cls.element_type
+
+            try:
+                pf_objects = app.GetCalcRelevantObjects(f"*.{pf_class_name}")
+            except (RuntimeError, AttributeError):
+                pf_objects = list()
+
+            if pf_objects:
+                target_list = self._CLASS_TO_LIST[dgs_cls]
+
+                for pf_obj in pf_objects:
+                    elem = _populate_from_pf_object(pf_obj, dgs_cls)
+                    target_list.append(elem)