VeraGridEngine 5.4.4__tar.gz → 5.4.5__tar.gz

{veragridengine-5.4.4 → veragridengine-5.4.5}/PKG-INFO

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

@@ -676,7 +676,7 @@ def convert_bus(elm: dev.Bus, n_time: int,
     :return:
     """
     bus = pg.Bus(nt=n_time,
-                 name=elm.name,
+                 name=str(elm.name),
                  idtag=elm.idtag,
                  code=str(elm.code),
                  Vnom=elm.Vnom,

{veragridengine-5.4.4 → veragridengine-5.4.5}/VeraGridEngine/Devices/Branches/tap_changer.py

@@ -355,7 +355,7 @@ class TapChanger:
 
         elif self.tc_type == TapChangerTypes.VoltageRegulation:
             ndu = self._ndv[tap_position]
-            return 1.0 / (1.0 - ndu)
+            return 1.0 / (1.0 - ndu + 1e-20)
 
         elif self.tc_type == TapChangerTypes.Asymmetrical:
             ndu = self._ndv[tap_position]

{veragridengine-5.4.4 → veragridengine-5.4.5}/VeraGridEngine/Devices/assets.py

@@ -6152,6 +6152,8 @@ class Assets:
         elif obj.device_type == DeviceType.RmsModelTemplateDevice:
             self.add_rms_model(obj=obj)
 
+        elif obj.device_type == DeviceType.SwitchDevice:
+            self.add_switch(obj=obj)
         else:
             raise Exception('Element type not understood ' + str(obj.device_type))
 

{veragridengine-5.4.4 → veragridengine-5.4.5}/VeraGridEngine/Devices/multi_circuit.py

@@ -2090,7 +2090,7 @@ class MultiCircuit(Assets):
                 # not found in the base, add it
                 action = ActionType.Add
 
-            else:
+            elif type(new_elm) == type(elm_from_base):
                 # check differences
                 action, changed_props = elm_from_base.compare(
                     other=new_elm,
@@ -2098,6 +2098,12 @@ class MultiCircuit(Assets):
                     detailed_profile_comparison=detailed_profile_comparison,
                     nt=nt
                 )
+            else:
+                # Same iftag, different classes, probably some consequence of CGMES
+                logger.add_info(msg="Same idtag, different types",
+                                device_class=new_elm.device_type.value,
+                                device_property=new_elm.name,
+                                expected_value=elm_from_base.device_type.value)
 
             if action != ActionType.NoAction:
                 new_element = new_elm.copy(forced_new_idtag=False)

{veragridengine-5.4.4 → veragridengine-5.4.5}/VeraGridEngine/IO/cim/cgmes/cgmes_to_veragrid.py

@@ -386,7 +386,9 @@ def get_gcdev_buses(cgmes_model: CgmesCircuit,
             code=cn_elm.description,
             name=cn_elm.name,
             Vnom=nominal_voltage,
-            is_slack=is_slack
+            is_slack=is_slack,
+            Va0=va,
+            Vm0=vm,
         )
 
         gc_model.add_bus(gcdev_elm)

{veragridengine-5.4.4 → veragridengine-5.4.5}/VeraGridEngine/IO/cim/cgmes/cgmes_utils.py

@@ -549,16 +549,25 @@ def get_nominal_voltage_for_cn(cn: CGMES_CONNECTIVITY_NODE, logger: DataLogger)
     :return: hopefully the nominal voltage
     """
     if hasattr(cn, 'ConnectivityNodeContainer'):
-        if hasattr(cn.ConnectivityNodeContainer, 'BaseVoltage'):
-            if cn.ConnectivityNodeContainer.BaseVoltage is not None:
-                if not isinstance(cn.ConnectivityNodeContainer.BaseVoltage, str):
-                    return float(cn.ConnectivityNodeContainer.BaseVoltage.nominalVoltage)
+        if hasattr(cn.ConnectivityNodeContainer, 'VoltageLevel'):
+            if hasattr(cn.ConnectivityNodeContainer.VoltageLevel, 'BaseVoltage'):
+                if cn.ConnectivityNodeContainer.VoltageLevel.BaseVoltage is not None:
+                    if not isinstance(cn.ConnectivityNodeContainer.VoltageLevel.BaseVoltage.nominalVoltage, str):
+                        return float(cn.ConnectivityNodeContainer.VoltageLevel.BaseVoltage.nominalVoltage)
+                    else:
+                        logger.add_error(msg='Missing reference',
+                                         device=cn.rdfid,
+                                         device_class=cn.tpe,
+                                         device_property="nominalVoltage",
+                                         value=cn.ConnectivityNodeContainer.VoltageLevel.BaseVoltage,
+                                         expected_value='object')
+                        return 0.0
                 else:
                     logger.add_error(msg='Missing reference',
                                      device=cn.rdfid,
                                      device_class=cn.tpe,
-                                     device_property="BaseVoltage",
-                                     value=cn.ConnectivityNodeContainer.BaseVoltage,
+                                     device_property="nominalVoltage",
+                                     value=cn.ConnectivityNodeContainer,
                                      expected_value='object')
                     return 0.0
             else:
@@ -570,13 +579,34 @@ def get_nominal_voltage_for_cn(cn: CGMES_CONNECTIVITY_NODE, logger: DataLogger)
                                  expected_value='object')
                 return 0.0
         else:
-            logger.add_error(msg='Missing reference',
-                             device=cn.rdfid,
-                             device_class=cn.tpe,
-                             device_property="BaseVoltage",
-                             value=cn.ConnectivityNodeContainer,
-                             expected_value='object')
-            return 0.0
+            if hasattr(cn.ConnectivityNodeContainer, 'BaseVoltage'):
+                if cn.ConnectivityNodeContainer.BaseVoltage is not None:
+                    if not isinstance(cn.ConnectivityNodeContainer.BaseVoltage.nominalVoltage, str):
+                        return float(cn.ConnectivityNodeContainer.BaseVoltage.nominalVoltage)
+                    else:
+                        logger.add_error(msg='Missing reference',
+                                         device=cn.rdfid,
+                                         device_class=cn.tpe,
+                                         device_property="nominalVoltage",
+                                         value=cn.ConnectivityNodeContainer.BaseVoltage,
+                                         expected_value='object')
+                        return 0.0
+                else:
+                    logger.add_error(msg='Missing reference',
+                                     device=cn.rdfid,
+                                     device_class=cn.tpe,
+                                     device_property="nominalVoltage",
+                                     value=cn.ConnectivityNodeContainer,
+                                     expected_value='object')
+                    return 0.0
+            else:
+                logger.add_error(msg='Missing reference',
+                                 device=cn.rdfid,
+                                 device_class=cn.tpe,
+                                 device_property="BaseVoltage",
+                                 value=cn.ConnectivityNodeContainer,
+                                 expected_value='object')
+                return 0.0
     else:
         logger.add_error(msg='Missing reference',
                          device=cn.rdfid,

{veragridengine-5.4.4 → veragridengine-5.4.5}/VeraGridEngine/IO/others/pandapower_parser.py

@@ -8,11 +8,12 @@ import math
 from typing import Dict
 import sqlite3
 import json
-
+import numpy as np
 import pandas as pd
 
 import VeraGridEngine.Devices as dev
-from VeraGridEngine import ExternalGridMode
+from VeraGridEngine import TapChanger
+from VeraGridEngine.enumerations import (ExternalGridMode, TapChangerTypes)
 from VeraGridEngine.Devices.types import ALL_DEV_TYPES
 from VeraGridEngine.basic_structures import Logger
 
@@ -207,7 +208,7 @@ class Panda2VeraGrid:
                 name=row['name'],
                 code=idx,
                 Vm=row['vm_pu'],
-                mode= ExternalGridMode.VD,
+                mode=ExternalGridMode.VD,
                 idtag=row.get('uuid', None)
             )
 
@@ -413,7 +414,7 @@ class Panda2VeraGrid:
 
             elm.rdfid = row.get('uuid', elm.idtag)
 
-            grid.add_generator(bus=bus, api_obj=elm)  # Add generator to the grid
+            grid.add_static_generator(bus=bus, api_obj=elm)  # Add generator to the grid
 
             self.register(panda_type="sgen", panda_code=idx, api_obj=elm)
 
@@ -427,7 +428,6 @@ class Panda2VeraGrid:
         for idx, row in self.panda_net.trafo.iterrows():
             bus1 = bus_dictionary[row['hv_bus']]
             bus2 = bus_dictionary[row['lv_bus']]
-
             elm = dev.Transformer2W(
                 bus_from=bus1,
                 bus_to=bus2,
@@ -441,16 +441,12 @@ class Panda2VeraGrid:
             )
             elm.rdfid = row.get('uuid', elm.idtag)
             # --- Derived values ---
-            if "vkr_percent" in row:
-                Pcu = row["vkr_percent"] / 100 * row["sn_mva"] * 1000  # copper losses in kW
-            else:
-                Pcu = 0
-            Pfe = row["pfe_kw"]  # iron losses in kW
-
-            Irated = row['sn_mva'] * 1e6 / (math.sqrt(3) * row['vn_hv_kv'] * 1e3)
-            I0 = row['i0_percent'] / 100 * Irated  # no-load current in A
 
-            Vsc = row["vk_percent"]  # short-circuit voltage (%)
+            # see: https://pandapower.readthedocs.io/en/latest/elements/trafo.html#trafo
+            Pcu = row.get("vkr_percent", 0.0) / 100 * row["sn_mva"] * 1000  # copper losses in kW
+            Pfe = row.get("pfe_kw", 0.0)  # iron losses in kW
+            I0 = row.get('i0_percent', 0.0)  # no-load current in %
+            Vsc = row.get("vk_percent", 0.0)  # short-circuit voltage (%)
 
             elm.fill_design_properties(
                 Pcu=Pcu,
@@ -460,10 +456,161 @@ class Panda2VeraGrid:
                 Sbase=grid.Sbase
             )
 
+            tc = self.extract_tap_changers(row)
+            if tc is not None:
+                elm.tap_changer = tc
+
             grid.add_transformer2w(elm)
 
             self.register(panda_type="trafo", panda_code=idx, api_obj=elm)
 
+    def extract_tap_changers(self, row) -> TapChanger | None:
+        """
+            # Tap changer mapping (pandapower → GridCal)
+            #
+            # Ratio + tap_step_percent only:
+            #   dV = tap_step_percent / 100
+            #   asymmetry_angle = 0°
+            #
+            # Ratio + tap_step_percent + tap_step_degree (cross regulator):
+            #   δu = tap_step_percent / 100
+            #   α = tap_step_degree  (phase shift per tap, deg)
+            #
+            #   Conversion (UCTE):
+            #     tan(α) = (δu · sinΘ) / (1 + δu · cosΘ)
+            #     ⇒ Θ = α + arcsin(sin(α) / δu)
+            #
+            #   If δu = 0 or |sin(α)| > δu:
+            #     Fallback → treat as Ideal phase shifter:
+            #       dV = 0
+            #       asymmetry_angle = α
+            #
+            # Symmetrical:
+            #   dV = tap_step_percent / 100
+            #   asymmetry_angle = 90°
+            #
+            # Ideal:
+            #   dV = 0
+            #   asymmetry_angle = tap_step_degree For "Symmetrical" and "Ideal", mapping stays as before.
+        """
+        tap_changer_type = row.get("tap_changer_type", None)
+        dV = 0.0
+        asymmetry_angle = 0.0
+        tc_type = TapChangerTypes.NoRegulation
+        if tap_changer_type is not None and pd.notna(row["tap_neutral"]):
+            if tap_changer_type == "Ratio":
+                # Longitudinal regulator
+                dV = row['tap_step_percent'] / 100.0
+                asymmetry_angle = 0.0
+                tc_type = TapChangerTypes.VoltageRegulation
+
+                # Check if cross regulator (with angle)
+                if "tap_step_degree" in row and row["tap_step_degree"] != 0.0:
+                    alpha = np.deg2rad(row["tap_step_degree"])  # pandapower phase shift α [rad]
+                    if dV > 0 and abs(np.sin(alpha)) <= dV:
+                        # Convert α -> Θ (GridCal asymmetry_angle)
+                        theta = alpha + np.arcsin(np.sin(alpha) / dV)
+                        asymmetry_angle = np.rad2deg(theta)
+                        tc_type = TapChangerTypes.Asymmetrical
+                    else:
+                        # fallback: cannot map with given dV, treat as ideal angle shifter
+                        asymmetry_angle = row["tap_step_degree"]
+                        dV = 0.0
+                        tc_type = TapChangerTypes.Asymmetrical
+
+            elif tap_changer_type == "Symmetrical":
+                dV = row['tap_step_percent'] / 100.0
+                asymmetry_angle = 90.0
+                tc_type = TapChangerTypes.Symmetrical
+
+            elif tap_changer_type == "Ideal":
+                dV = 0.0
+                tc_type = TapChangerTypes.Asymmetrical
+                asymmetry_angle = row.get("tap_step_degree", 90.0)  # default to 90° if missing
+
+            else:
+                tc_type = TapChangerTypes.NoRegulation
+                dV = 0.0
+                asymmetry_angle = 90.0
+
+            # Build GridCal TapChanger
+            return dev.TapChanger(
+                total_positions=row['tap_max'] - row['tap_min'] + 1,
+                neutral_position=row['tap_neutral'],
+                normal_position=row['tap_pos'],
+                dV=dV,
+                asymmetry_angle=asymmetry_angle,
+                tc_type=tc_type
+            )
+        else:
+            return None
+
+    def parse_transformers3W(self, grid: dev.MultiCircuit, bus_dictionary: Dict[str, dev.Bus]):
+        """
+        Add 3W transformers to the VeraGrid grid
+        :param grid: MultiCircuit grid
+        :param bus_dictionary:
+        """
+
+        for idx, row in self.panda_net.trafo3w.iterrows():
+            bus_hv = bus_dictionary[row['hv_bus']]
+            bus_mv = bus_dictionary[row['mv_bus']]
+            bus_lv = bus_dictionary[row['lv_bus']]
+            # Nominal voltages
+            V1, V2, V3 = row.vn_hv_kv, row.vn_mv_kv, row.vn_lv_kv
+
+            # Ratings (if available, else default to 100 MVA)
+            Sn1 = getattr(row, "sn_hv_mva", grid.Sbase)
+            Sn2 = getattr(row, "sn_mv_mva", grid.Sbase)
+            Sn3 = getattr(row, "sn_lv_mva", grid.Sbase)
+
+            # Build transformer
+            elm = dev.Transformer3W(
+                idtag=str(row.uuid),
+                code=str(idx),
+                name=str(row.name),
+                bus1=bus_hv,
+                bus2=bus_mv,
+                bus3=bus_lv,
+                V1=V1, V2=V2, V3=V3,
+                r12=0.0, r23=0.0, r31=0.0,  # will be recomputed
+                x12=0.0, x23=0.0, x31=0.0,
+                rate12=Sn1, rate23=Sn2, rate31=Sn3,
+            )
+            elm.rdfid = row.get('uuid', elm.idtag)
+            # --- Derived values ---
+            # Copper losses [kW] and short-circuit voltages [%]
+
+            Pfe = row.get("pfe_kw", 0.0)  # iron losses in kW
+            I0 = row.get('i0_percent', 0.0)
+
+            # short-circuit voltage (%)
+            Vsc12 = row.get("vk_hv_percent", 0.0)
+            Vsc23 = row.get("vk_mv_percent", 0.0)
+            Vsc31 = row.get("vk_lv_percent", 0.0)
+
+            # see: https://pandapower.readthedocs.io/en/latest/elements/trafo.html#trafo
+            Pcu12 = row.get("vkr_hv_percent", 0.0) / 100.0 * Sn1 * 1000.0  # copper losses in kW
+            Pcu23 = row.get("vkr_mv_percent", 0.0) / 100.0 * Sn2 * 1000.0  # copper losses in kW
+            Pcu31 = row.get("vkr_lv_percent", 0.0) / 100.0 * Sn3 * 1000.0  # copper losses in kW
+
+            # Fill design values (VeraGrid computes r,x from % values)
+            elm.fill_from_design_values(
+                V1=V1, V2=V2, V3=V3,
+                Sn1=Sn1, Sn2=Sn2, Sn3=Sn3,
+                Pcu12=Pcu12, Pcu23=Pcu23, Pcu31=Pcu31,
+                Vsc12=Vsc12, Vsc23=Vsc23, Vsc31=Vsc31,
+                Pfe=Pfe, I0=I0, Sbase=grid.Sbase,
+            )
+
+            tc = self.extract_tap_changers(row)
+            if tc is not None:
+                elm.winding1.tap_changer = tc
+
+            grid.add_transformer3w(elm)
+
+            self.register(panda_type="trafo3w", panda_code=idx, api_obj=elm)
+
     def parse_switches(self, grid: dev.MultiCircuit, bus_dictionary: Dict[str, dev.Bus]):
         """
 
@@ -571,8 +718,8 @@ class Panda2VeraGrid:
                                 name=name)
                             )
                         elif m_tpe == "va":
-                            grid.add_va_measurement(dev.VaMeasurement(value=val,uncertainty = std,api_obj=api_object,
-                                                                      name = name))
+                            grid.add_va_measurement(dev.VaMeasurement(value=val, uncertainty=std, api_obj=api_object,
+                                                                      name=name))
                         elif m_tpe == 'p':
                             grid.add_pi_measurement(dev.PiMeasurement(
                                 value=val,
@@ -735,7 +882,7 @@ class Panda2VeraGrid:
         grid = dev.MultiCircuit()
 
         if self.panda_net is not None:
-            #grid.Sbase = self.panda_net.sn_mva if self.panda_net.sn_mva > 0.0 else 100.0  # always, the pandapower
+            # grid.Sbase = self.panda_net.sn_mva if self.panda_net.sn_mva > 0.0 else 100.0  # always, the pandapower
             # For pandapwoer Sbase is crazily affecting only load
             grid.Sbase = 100.0  # always, the pandapower
             # scaling is handled in the conversions
@@ -751,6 +898,7 @@ class Panda2VeraGrid:
             self.parse_generators(grid=grid, bus_dictionary=bus_dict)
             self.parse_static_generators(grid=grid, bus_dictionary=bus_dict)
             self.parse_transformers(grid=grid, bus_dictionary=bus_dict)
+            self.parse_transformers3W(grid=grid, bus_dictionary=bus_dict)
             self.parse_switches(grid=grid, bus_dictionary=bus_dict)
             self.parse_measurements(grid=grid)
 

{veragridengine-5.4.4 → veragridengine-5.4.5}/VeraGridEngine/Simulations/InputsAnalysis/inputs_analysis_driver.py

@@ -84,23 +84,32 @@ class InputsAnalysisResults(ResultsTemplate):
         """
         dta = list()
         for k, elm in enumerate(self.grid.get_generators()):
+            if elm is not None:
+                if self.opf_results is None:
+                    P = elm.P * elm.active
+                else:
+                    P = self.opf_results.generator_power[k] - self.opf_results.generator_shedding[k]
+
+                if elm.bus is None:
+                    zone = ""
+                    area = ""
+                    substation = ""
+                    country = ""
+                else:
+                    zone = elm.bus.zone.name if elm.bus.zone is not None else ""
+                    area = elm.bus.area.name if elm.bus.area is not None else ""
+                    substation = elm.bus.substation.name if elm.bus.substation is not None else ""
+                    country = elm.bus.country.name if elm.bus.country is not None else ""
+
+                dta.append([elm.name,
+                            P,
+                            elm.Pf,
+                            elm.Snom,
+                            elm.Pmin, elm.Pmax,
+                            elm.Qmin, elm.Qmax,
+                            elm.Vset,
+                            zone, area, substation, country])
 
-            if self.opf_results is None:
-                P = elm.P * elm.active
-            else:
-                P = self.opf_results.generator_power[k] - self.opf_results.generator_shedding[k]
-
-            dta.append([elm.name,
-                        P,
-                        elm.Pf,
-                        elm.Snom,
-                        elm.Pmin, elm.Pmax,
-                        elm.Qmin, elm.Qmax,
-                        elm.Vset,
-                        elm.bus.zone.name if elm.bus.zone is not None else "",
-                        elm.bus.area.name if elm.bus.area is not None else "",
-                        elm.bus.substation.name if elm.bus.substation is not None else "",
-                        elm.bus.country.name if elm.bus.country is not None else ""])
         cols = ['Name', 'P', 'Pf',
                 'Snom', 'Pmin', 'Pmax',
                 'Qmin', 'Qmax', 'Vset',
@@ -114,17 +123,27 @@ class InputsAnalysisResults(ResultsTemplate):
         """
         dta = list()
         for elm in self.grid.get_batteries():
-            dta.append([elm.name,
-                        elm.P * elm.active,
-                        elm.Pf,
-                        elm.Snom,
-                        elm.Pmin, elm.Pmax,
-                        elm.Qmin, elm.Qmax,
-                        elm.Vset,
-                        elm.bus.zone.name if elm.bus.zone is not None else "",
-                        elm.bus.area.name if elm.bus.area is not None else "",
-                        elm.bus.substation.name if elm.bus.substation is not None else "",
-                        elm.bus.country.name if elm.bus.country is not None else ""])
+            if elm is not None:
+                if elm.bus is None:
+                    zone = ""
+                    area = ""
+                    substation = ""
+                    country = ""
+                else:
+                    zone = elm.bus.zone.name if elm.bus.zone is not None else ""
+                    area = elm.bus.area.name if elm.bus.area is not None else ""
+                    substation = elm.bus.substation.name if elm.bus.substation is not None else ""
+                    country = elm.bus.country.name if elm.bus.country is not None else ""
+
+                dta.append([elm.name,
+                            elm.P * elm.active,
+                            elm.Pf,
+                            elm.Snom,
+                            elm.Pmin, elm.Pmax,
+                            elm.Qmin, elm.Qmax,
+                            elm.Vset,
+                            zone, area, substation, country])
+
         cols = ['Name', 'P', 'Pf',
                 'Snom', 'Pmin', 'Pmax',
                 'Qmin', 'Qmax', 'Vset',
@@ -138,13 +157,23 @@ class InputsAnalysisResults(ResultsTemplate):
         """
         dta = list()
         for elm in self.grid.get_loads():
-            dta.append([elm.name,
-                        elm.P * elm.active,
-                        elm.Q * elm.active,
-                        elm.bus.zone.name if elm.bus.zone is not None else "",
-                        elm.bus.area.name if elm.bus.area is not None else "",
-                        elm.bus.substation.name if elm.bus.substation is not None else "",
-                        elm.bus.country.name if elm.bus.country is not None else ""])
+            if elm is not None:
+                if elm.bus is None:
+                    zone = ""
+                    area = ""
+                    substation = ""
+                    country = ""
+                else:
+                    zone = elm.bus.zone.name if elm.bus.zone is not None else ""
+                    area = elm.bus.area.name if elm.bus.area is not None else ""
+                    substation = elm.bus.substation.name if elm.bus.substation is not None else ""
+                    country = elm.bus.country.name if elm.bus.country is not None else ""
+
+                dta.append([elm.name,
+                            elm.P * elm.active,
+                            elm.Q * elm.active,
+                            zone, area, substation, country])
+
         cols = ['Name', 'P', 'Q',
                 'Zone', 'Area', 'Substation', 'Country']
         return pd.DataFrame(data=dta, columns=cols)
@@ -156,13 +185,23 @@ class InputsAnalysisResults(ResultsTemplate):
         """
         dta = list()
         for elm in self.grid.get_static_generators():
-            dta.append([elm.name,
-                        elm.P * elm.active,
-                        elm.Q * elm.active,
-                        elm.bus.zone.name if elm.bus.zone is not None else "",
-                        elm.bus.area.name if elm.bus.area is not None else "",
-                        elm.bus.substation.name if elm.bus.substation is not None else "",
-                        elm.bus.country.name if elm.bus.country is not None else ""])
+            if elm is not None:
+                if elm.bus is None:
+                    zone = ""
+                    area = ""
+                    substation = ""
+                    country = ""
+                else:
+                    zone = elm.bus.zone.name if elm.bus.zone is not None else ""
+                    area = elm.bus.area.name if elm.bus.area is not None else ""
+                    substation = elm.bus.substation.name if elm.bus.substation is not None else ""
+                    country = elm.bus.country.name if elm.bus.country is not None else ""
+
+                dta.append([elm.name,
+                            elm.P * elm.active,
+                            elm.Q * elm.active,
+                            zone, area, substation, country])
+
         cols = ['Name', 'P', 'Q',
                 'Zone', 'Area', 'Substation', 'Country']
         return pd.DataFrame(data=dta, columns=cols)
@@ -248,7 +287,7 @@ class InputsAnalysisResults(ResultsTemplate):
         """
 
         :param elms:
-        :param magnitude:snaphot property name
+        :param magnitude: Snapshot property name
         :param aggregation:
         :return:
         """

{veragridengine-5.4.4 → veragridengine-5.4.5}/VeraGridEngine/Simulations/PowerFlow/__init__.py

@@ -11,3 +11,4 @@ from VeraGridEngine.Simulations.PowerFlow.power_flow_ts_driver import PowerFlowT
 from VeraGridEngine.Simulations.PowerFlow.power_flow_ts_results import PowerFlowTimeSeriesResults
 from VeraGridEngine.Simulations.PowerFlow.power_flow_ts_input import PowerFlowTimeSeriesInput
 from VeraGridEngine.Simulations.PowerFlow.power_flow_results import PowerFlowResults
+from VeraGridEngine.Simulations.PowerFlow.power_flow_results_3ph import PowerFlowResults3Ph

{veragridengine-5.4.4 → veragridengine-5.4.5}/VeraGridEngine/Simulations/PowerFlow/power_flow_results_3ph.py

@@ -599,20 +599,22 @@ class PowerFlowResults3Ph(ResultsTemplate):
             "QlossC": self.losses_C.imag,
         }, index=self.branch_names)
 
-    def get_voltage_df(self) -> pd.DataFrame:
+    def get_voltage_3ph_df(self) -> pd.DataFrame:
         """
-        Get a DataFrame with the buses results
-        :return: DataFrame, Vm in p.u., Va in deg, P in MW, Q in MVAr
+        Get a DataFrame with the buses results, Vm in p.u., Va in deg
+        :return: DataFrame
         """
-        return pd.DataFrame(data={
-            'Vm_A': np.abs(self.voltage_A),
-            'Vm_B': np.abs(self.voltage_B),
-            'Vm_C': np.abs(self.voltage_C),
-            'Va_A': np.angle(self.voltage_A, deg=True),
-            'Va_B': np.angle(self.voltage_B, deg=True),
-            'Va_C': np.angle(self.voltage_C, deg=True)
+        df = pd.DataFrame(data={
+            'Vm_A': np.abs(self.voltage_A).round(5),
+            'Vm_B': np.abs(self.voltage_B).round(5),
+            'Vm_C': np.abs(self.voltage_C).round(5),
+            'Va_A': np.angle(self.voltage_A, deg=True).round(1),
+            'Va_B': np.angle(self.voltage_B, deg=True).round(1),
+            'Va_C': np.angle(self.voltage_C, deg=True).round(1)
         }, index=self.bus_names)
 
+        return df
+
     def export_all(self):
         """
         Exports all the results to DataFrames.

{veragridengine-5.4.4 → veragridengine-5.4.5}/VeraGridEngine/Simulations/StateEstimation/state_estimation.py

@@ -8,9 +8,8 @@ from typing import Tuple
 
 import pandas as pd
 from scipy import sparse
-from scipy.linalg import lstsq
 from scipy.sparse import hstack as sphs, vstack as spvs, csc_matrix, diags
-from scipy.sparse.linalg import factorized, spsolve, spilu, splu, lsqr
+from scipy.sparse.linalg import factorized, spsolve, spilu, splu, eigsh
 import numpy as np
 from VeraGridEngine.Simulations.StateEstimation.state_estimation_inputs import StateEstimationInput
 from VeraGridEngine.Simulations.PowerFlow.NumericalMethods.common_functions import power_flow_post_process_nonlinear
@@ -223,6 +222,7 @@ def b_test(sigma2: Vec,
     :param dz: residuals r = z - h(x^) (length m)
     :param HtWH: G = H^T W H (k x k)
     :param c_threshold: detection threshold 'c' (use 4.0 as in the paper)
+    :param logger: Logger
     :return:
         'r'      : residuals r_i
         'sigma2' : sigma_i^2
@@ -239,7 +239,7 @@ def b_test(sigma2: Vec,
     # Use LU so we can reuse for many RHS
     lu = factorized(HtWH.tocsc())
     # For the system to be observable the eigenvalues should be greater than zero -> matrix pos definate
-    eigvals = np.linalg.eigvalsh(HtWH.toarray())
+    eigvals, _ = eigsh(HtWH)
     assert np.all(eigvals > 0), "Unobservable-System"
 
     # Compute h_i = H_i G^{-1} H_i^T and then Pii = sigma_i^2 - h_i
@@ -1120,7 +1120,7 @@ def decoupled_state_estimation(nc: NumericalCircuit,
             lu_ga = splu(Ga)
             dtheta = lu_ga.solve(Ta)
         except Exception:
-            dtheta = lstsq(Ga.toarray(), Ta, rcond=None)[0]
+            dtheta = spilu(Ga).solve(Ta)
 
         # safety clip + apply relaxation
         if np.any(np.abs(dtheta) > max_theta_step):
@@ -1148,7 +1148,7 @@ def decoupled_state_estimation(nc: NumericalCircuit,
             lu_gr = splu(Gr)
             dV = lu_gr.solve(Tr)
         except Exception:
-            dV = lstsq(Gr.toarray(), Tr, rcond=None)[0]
+            dV = spilu(Gr).solve(Tr)
 
         # safety clip + apply relaxation
         if np.any(np.abs(dV) > max_V_step):

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