VeraGridEngine 6.2.4__tar.gz → 6.2.6__tar.gz

{veragridengine-6.2.4 → veragridengine-6.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VeraGridEngine
-Version: 6.2.4
+Version: 6.2.6
 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-6.2.4 → veragridengine-6.2.6}/VeraGridEngine/Devices/Dynamic/static_parameter_mapping.py

@@ -2266,18 +2266,13 @@ def assign_load_static_api_mapping(
     sbase: float = float(grid.Sbase)
 
     if load.bus.is_dc:
-        # DC loads use the historical EMT convention: explicit conductance is
-        # used when available; otherwise active power is represented as an
-        # equivalent conductance on the DC base.
+        # DC loads follow the same ZIP semantics as the generic load device.
+        # The constant-power term stays in ``Pl0`` and the impedance term stays
+        # in ``g`` so the EMT and RMS representations preserve the user-declared
+        # physical meaning instead of silently rewriting one term into another.
         dc_p_value: float = float(load.P) / sbase
         dc_g_value: float = float(load.G) / sbase
 
-        if dc_g_value == 0.0:
-            dc_p_value = 0.0
-            dc_g_value = float(load.P) / sbase
-        else:
-            pass
-
         assign_api_mapping_value_if_present(
             mdl=mdl,
             key=ParamPowerFlowReferenceType.Pl0,

{veragridengine-6.2.4 → veragridengine-6.2.6}/VeraGridEngine/Devices/Dynamic/static_parameter_mapping_rms.py

@@ -2005,18 +2005,13 @@ def assign_load_static_api_mapping(
     )
 
     if load.bus.is_dc:
-        # DC loads use the historical EMT convention: explicit conductance is
-        # used when available; otherwise active power is represented as an
-        # equivalent conductance on the DC base.
+        # DC loads follow the same ZIP semantics as the generic load device.
+        # The constant-power term stays in ``Pl0`` and the impedance term stays
+        # in ``g`` so the EMT and RMS representations preserve the user-declared
+        # physical meaning instead of silently rewriting one term into another.
         dc_p_value: float = float(load.P) / sbase
         dc_g_value: float = float(load.G) / sbase
 
-        if dc_g_value == 0.0:
-            dc_p_value = 0.0
-            dc_g_value = float(load.P) / sbase
-        else:
-            pass
-
         assign_api_mapping_value_if_present(
             mdl=mdl,
             key=ParamPowerFlowReferenceType.Pl0,

{veragridengine-6.2.4 → veragridengine-6.2.6}/VeraGridEngine/Devices/multiverse.py

@@ -486,6 +486,9 @@ class MultiVerse:
     def roots_number(self):
         return len(self._root_nodes)
 
+    def check_node(self, node_id: int) -> bool:
+        return node_id in self._nodes_by_id
+
     def get_node(self, node_id: int) -> ScenarioNode:
         """
 
@@ -766,31 +769,36 @@ class MultiVerse:
                 position_raw = record.get("position", None)
                 position = None if position_raw is None else int(position_raw)
 
-                node = ScenarioNode(
-                    node_id=node_id,
-                    data=diffs_dict[circuit_idtag],
-                    diagrams=diffs_dict[circuit_idtag].diagrams,
-                    parent=parent,
-                )
-
-                if parent is None:
-                    if position is None:
-                        self._root_nodes.append(node)
+                data = diffs_dict.get(circuit_idtag, None)
+
+                if data is not None:
+                    node = ScenarioNode(
+                        node_id=node_id,
+                        data=data,
+                        diagrams=data.diagrams,
+                        parent=parent,
+                    )
+
+                    if parent is None:
+                        if position is None:
+                            self._root_nodes.append(node)
+                        else:
+                            self._root_nodes.insert(position, node)
                     else:
-                        self._root_nodes.insert(position, node)
+                        if position is None:
+                            parent.append_child(node)
+                        else:
+                            parent.insert_child(position, node)
+
+                    self.set_node(node_id, node)
+                    built_nodes[node_id] = node
+                    del pending[metadata_node_id]
+                    progressed = True
+
+                    if node_id > max_id:
+                        max_id = node_id
                 else:
-                    if position is None:
-                        parent.append_child(node)
-                    else:
-                        parent.insert_child(position, node)
-
-                self.set_node(node_id, node)
-                built_nodes[node_id] = node
-                del pending[metadata_node_id]
-                progressed = True
-
-                if node_id > max_id:
-                    max_id = node_id
+                    pass
 
             if not progressed:
                 unresolved = ", ".join(str(node_id) for node_id in pending.keys())

{veragridengine-6.2.4 → veragridengine-6.2.6}/VeraGridEngine/IO/file_open.py

@@ -395,7 +395,7 @@ class FileOpen:
                                                             progress_func=progress_func,
                                                             logger=self.logger)
                 # interpret file content
-                if data_dictionary is not None:
+                if isinstance(data_dictionary, dict):
                     if has_multiverse_data:
                         self.multiverse = parse_multiverse_data(data=data_dictionary,
                                                                 metadata=self.json_files["metadata"],

{veragridengine-6.2.4 → veragridengine-6.2.6}/VeraGridEngine/IO/veragrid/pack_unpack.py

@@ -23,6 +23,13 @@ from VeraGridEngine.Devices.Diagrams.base_diagram import copy_diagrams
 from VeraGridEngine.enumerations import (DiagramType, DeviceType, SubObjectType, TapPhaseControl, TapModuleControl,
                                          ContingencyOperationTypes)
 
+ProfileDictionary = Dict[str, bool | int | str | dict[str, dict[int, Any | None] | dict[Any, Any]] | Any]
+
+ModelDictionary = dict[str,
+dict[str, dict[str, str] | list[dict[str, str]]]
+| dict[str, list[dict[str, Any]] | dict[int, list[Any]] | dict[int, dict[str, Any]] | list[int]]
+]
+
 
 def get_objects_dictionary() -> Dict[str, ALL_DEV_TYPES]:
     """
@@ -239,7 +246,8 @@ def _resolve_circuit_fmu_paths(circuit: MultiCircuit, project_directory: Path |
                 if property_name in elm.registered_properties:
                     current_value = elm.get_snapshot_value_by_name(property_name)
                     if isinstance(current_value, str):
-                        elm.set_snapshot_value(property_name, _resolve_project_fmu_config(current_value, project_directory))
+                        elm.set_snapshot_value(property_name,
+                                               _resolve_project_fmu_config(current_value, project_directory))
                     else:
                         pass
                 else:
@@ -300,7 +308,7 @@ def get_multiverse_node_metadata(metadata: Dict[str, Any]) -> Dict[str, Dict[str
     return metadata
 
 
-def order_multiverse_records(metadata: Dict[str, Dict[str | int | float]] | Dict[str, Any]) -> List[Dict[str, Any]]:
+def order_multiverse_records(metadata: Dict[str, Dict[str, int | float]] | Dict[str, Any]) -> List[Dict[str, Any]]:
     """
     Return multiverse metadata records in a parent-before-child order.
 
@@ -458,7 +466,7 @@ def gather_model_as_data_frames(circuit: MultiCircuit,
     return dfs
 
 
-def profile_todict(profile: AnyProfile) -> Dict[str, str | bool]:
+def profile_todict(profile: AnyProfile) -> ProfileDictionary:
     """
     Get a dictionary representation of the profile
     :return:
@@ -493,7 +501,7 @@ def profile_todict(profile: AnyProfile) -> Dict[str, str | bool]:
         }
 
 
-def profile_todict_idtag(profile: AnyProfile) -> Dict[str, str]:
+def profile_todict_idtag(profile: AnyProfile) -> ProfileDictionary:
     """
     Get a dictionary representation of the profile
     :return:
@@ -521,7 +529,7 @@ def profile_todict_idtag(profile: AnyProfile) -> Dict[str, str]:
         }
 
 
-def profile_todict_str(profile: AnyProfile) -> Dict[str, str]:
+def profile_todict_str(profile: AnyProfile) -> ProfileDictionary:
     """
     Get a dictionary representation of the profile
     :return:
@@ -558,9 +566,9 @@ def profile_todict_str(profile: AnyProfile) -> Dict[str, str]:
 
 
 def cast_profile_value(
-    profile: AnyProfile,
-    value: Any,
-    collection: Union[None, Dict[str, Any]] = None,
+        profile: AnyProfile,
+        value: Any,
+        collection: Union[None, Dict[str, Any]] = None,
 ) -> Any:
     """
     Convert serialized profile payloads into the concrete type required by ``profile``.
@@ -752,12 +760,11 @@ def veragrid_object_to_json(elm: ALL_DEV_TYPES,
 
 
 def gather_model_as_jsons(circuit: MultiCircuit,
-                          project_directory: Path | None = None) -> dict[
-    str, dict[str, dict[str, str] | list[dict[str, str]]] | dict[
-        str, list[dict[str, Any]] | dict[int, list[Any]] | dict[int, dict[str, Any]] | list[int]]]:
+                          project_directory: Path | None = None) -> ModelDictionary:
     """
     Transform a MultiCircuit into a collection of Json files
     :param circuit:
+    :param project_directory:
     :return:
     """
 
@@ -1493,7 +1500,8 @@ def parse_object_type_from_json(template_elm: ALL_DEV_TYPES,
                                 elif gc_prop.tpe == SubObjectType.ImpedanceTripletList:
 
                                     # get the line locations object and fill it with the json data
-                                    impedance_triplet_list: dev.ImpedanceTripletList = elm.get_snapshot_value(prop=gc_prop)
+                                    impedance_triplet_list: dev.ImpedanceTripletList = elm.get_snapshot_value(
+                                        prop=gc_prop)
                                     impedance_triplet_list.parse(data=property_value)
 
                                 elif gc_prop.tpe == SubObjectType.TapChanger:
@@ -2057,8 +2065,8 @@ def parse_veragrid_data(data: VERAGRID_FILE_TYPE,
     return circuit
 
 
-def parse_multiverse_data(data: dict[str, VERAGRID_FILE_TYPE],
-                          metadata: Dict[str, Dict[str | int | float] | int | None],
+def parse_multiverse_data(data: Dict[str, VERAGRID_FILE_TYPE],
+                          metadata: Dict[str, Dict[str, int | float] | int | None],
                           text_func: Union[Callable, None] = None,
                           progress_func: Union[Callable, None] = None,
                           logger: Logger = Logger()) -> dev.MultiVerse:
@@ -2110,72 +2118,91 @@ def parse_multiverse_data(data: dict[str, VERAGRID_FILE_TYPE],
         parent_id_raw = record["parent_id"]
         parent_id = None if parent_id_raw is None else int(parent_id_raw)
 
-        model_data = data["multiverse"][circuit_idtag]
-        diagrams_dict[circuit_idtag] = model_data.get("diagrams", list())
+        multiverse_data = data.get("multiverse", None)
+        if multiverse_data is not None:
+            model_data = multiverse_data.get(circuit_idtag, None)
+
+            if model_data is not None:
+                diagrams_dict[circuit_idtag] = model_data.get("diagrams", list())
 
-        model_without_diagrams = dict(model_data)
-        model_without_diagrams["diagrams"] = list()
+                model_without_diagrams = dict(model_data)
+                model_without_diagrams["diagrams"] = list()
 
-        previous_circuit = None if parent_id is None else composed_by_node_id[parent_id]
+                previous_circuit = None if parent_id is None else composed_by_node_id[parent_id]
 
-        grid = parse_veragrid_data(data=model_without_diagrams,
-                                   previous_circuit=previous_circuit,
-                                   refine_pointers=False,
-                                   text_func=text_func,
-                                   progress_func=progress_func,
-                                   logger=logger)
+                grid = parse_veragrid_data(data=model_without_diagrams,
+                                           previous_circuit=previous_circuit,
+                                           refine_pointers=False,
+                                           text_func=text_func,
+                                           progress_func=progress_func,
+                                           logger=logger)
 
-        # we create a dictionary of all the elements in all the scenarios such that finding pointers doesn't fail later
-        d, ok = grid.get_all_elements_dict(logger=logger)
-        all_elements_dict.update(d)
+                # we create a dictionary of all the elements in all the scenarios such that finding pointers doesn't fail later
+                d, ok = grid.get_all_elements_dict(logger=logger)
+                all_elements_dict.update(d)
 
-        grid.idtag = circuit_idtag
-        diffs_dict[circuit_idtag] = grid
+                grid.idtag = circuit_idtag
+                diffs_dict[circuit_idtag] = grid
 
-        if parent_id is None:
-            composed_by_node_id[node_id] = grid.copy()
+                if parent_id is None:
+                    composed_by_node_id[node_id] = grid.copy()
+                else:
+                    composed = composed_by_node_id[parent_id].copy()
+                    composed.merge_circuit(grid)
+                    composed.name = grid.name
+                    composed_by_node_id[node_id] = composed
+            else:
+                # model_data is None
+                pass
         else:
-            composed = composed_by_node_id[parent_id].copy()
-            composed.merge_circuit(grid)
-            composed.name = grid.name
-            composed_by_node_id[node_id] = composed
+            # multiverse is None
+            pass
 
     # Refine pointer in all grids
     for idtag, grid in diffs_dict.items():
         grid.refine_pointer_objects(logger=logger, all_elements_dict=all_elements_dict)
 
-    mv.parse_json(diffs_dict, metadata)
+    # Parse the multiverse data
+    try:
+        mv.parse_json(diffs_dict=diffs_dict, metadata=metadata)
+    except ValueError as e:
+        logger.add_error(str(e))
 
     # Parse diagrams only after the multiverse tree exists, so each node can resolve them
     # against its full composed scenario instead of its raw delta payload.
     for record in node_metadata.values():
         node_id = int(record["node_id"])
         circuit_idtag = str(record["circuit_idtag"])
-        node = mv.get_node(node_id)
-        full_circuit = mv.checkout(node)
-        obj_dict = full_circuit.get_all_elements_dict_by_type(add_locations=True)
-        parsed_diagrams: List[Any] = list()
-
-        for diagram_dict in diagrams_dict.get(circuit_idtag, list()):
-            if diagram_dict['type'] in [DiagramType.Schematic.value, "bus-branch"]:
-                diagram = dev.SchematicDiagram()
-                diagram.parse_data(data=diagram_dict, obj_dict=obj_dict, logger=logger)
-                parsed_diagrams.append(diagram)
-
-            elif diagram_dict['type'] == DiagramType.SubstationLineMap.value:
-                diagram = dev.MapDiagram()
-                diagram.parse_data(data=diagram_dict, obj_dict=obj_dict, logger=logger)
-                parsed_diagrams.append(diagram)
-
-        node.diagrams = parsed_diagrams
-
-    active_node_id_raw = metadata.get("active_node_id", None) if isinstance(metadata, dict) else None
-    if mv.current_node is not None and mv.current_model is not None:
-        obj_dict = mv.current_model.get_all_elements_dict_by_type(add_locations=True)
-        mv.current_model.diagrams = copy_diagrams(diagrams=mv.current_node.diagrams, obj_dict=obj_dict)
-
-    if active_node_id_raw is not None and (
-            mv.current_node is None or mv.current_node.node_id != int(active_node_id_raw)):
-        mv.activate_scenario(int(active_node_id_raw))
+        if mv.check_node(node_id):
+            node = mv.get_node(node_id)
+            full_circuit = mv.checkout(node)
+            obj_dict = full_circuit.get_all_elements_dict_by_type(add_locations=True)
+            parsed_diagrams: List[Any] = list()
+
+            for diagram_dict in diagrams_dict.get(circuit_idtag, list()):
+                if diagram_dict['type'] in [DiagramType.Schematic.value, "bus-branch"]:
+                    diagram = dev.SchematicDiagram()
+                    diagram.parse_data(data=diagram_dict, obj_dict=obj_dict, logger=logger)
+                    parsed_diagrams.append(diagram)
+
+                elif diagram_dict['type'] == DiagramType.SubstationLineMap.value:
+                    diagram = dev.MapDiagram()
+                    diagram.parse_data(data=diagram_dict, obj_dict=obj_dict, logger=logger)
+                    parsed_diagrams.append(diagram)
+
+            node.diagrams = parsed_diagrams
+        else:
+            logger.add_error("Node ID not found", value=str(node_id))
+
+    if isinstance(metadata, dict):
+        active_node_id_raw: int = metadata.get("active_node_id", -1)
+        if mv.current_node is not None and mv.current_model is not None:
+            obj_dict = mv.current_model.get_all_elements_dict_by_type(add_locations=True)
+            mv.current_model.diagrams = copy_diagrams(diagrams=mv.current_node.diagrams, obj_dict=obj_dict)
+
+        if (active_node_id_raw > -1
+                and (mv.current_node is None or mv.current_node.node_id != int(active_node_id_raw))):
+            if mv.check_node(active_node_id_raw):
+                mv.activate_scenario(int(active_node_id_raw))
 
     return mv

{veragridengine-6.2.4 → veragridengine-6.2.6}/VeraGridEngine/Simulations/EMT/problems/emt_problem_dae.py

@@ -4876,12 +4876,19 @@ class EmtProblemDae(EmtProblemTemplate):
         """
         a = np.exp(1j * 2.0 * np.pi / 3.0)
 
-        V1 = (VA + a * VB + (a * a) * VC) / 3.0
-        I1 = (IA + a * IB + (a * a) * IC) / 3.0
+        # Build the balanced positive-sequence voltage from the PF bus phasors.
+        V1: complex = (VA + a * VB + (a * a) * VC) / 3.0
+        I1: complex = (IA + a * IB + (a * a) * IC) / 3.0
 
         phi_V = float(np.angle(V1))
         phi_I = float(np.angle(I1))
-        ang = phi_I - phi_V
+
+        # VSC EMT templates interpret ``phi`` in the converter-delivered-power
+        # convention while the PF branch current uses the network branch
+        # convention. Shifting by ``pi`` preserves the seeded current states and
+        # branch/KCL signs while making the analytical VSC power initialization
+        # consistent with positive converter export.
+        ang = phi_I - phi_V + np.pi
         phi = float(np.arctan2(np.sin(ang), np.cos(ang)))
 
         external_mapping: Optional[Dict[Any, Var]] = _get_external_mapping(mdl)
@@ -5912,17 +5919,20 @@ class EmtProblemDae(EmtProblemTemplate):
                     if abs(vt_ph) <= 1e-12:
                         i_t = 0.0 + 0.0j
                     else:
-                        i_t = np.conj(st_phase_total / vt_ph)
+                        i_t = np.conj(st_total / vt_ph)
+                        # i_t = np.conj(st_phase_total / vt_ph)
                 else:
                     if abs(vf_ph) <= 1e-12:
                         i_f = 0.0 + 0.0j
                     else:
-                        i_f = np.conj(sf_phase_total / vf_ph)
+                        i_f = np.conj(sf_total / vf_ph)
+                        # i_f = np.conj(sf_phase_total / vf_ph)
 
                     if abs(vt_ph) <= 1e-12:
                         i_t = 0.0 + 0.0j
                     else:
-                        i_t = np.conj(st_phase_total / vt_ph)
+                        i_t = np.conj(st_total / vt_ph)
+                        # i_t = np.conj(st_phase_total / vt_ph)
 
                 i_f0: float = np.sqrt(2.0) * np.imag(i_f)
                 i_t0: float = np.sqrt(2.0) * np.imag(i_t)
@@ -7186,6 +7196,17 @@ class EmtProblemDae(EmtProblemTemplate):
         from VeraGridEngine.Utils.procedural_logic import build_boundary_updater_from_block
         self._block_boundary_updater = build_boundary_updater_from_block(self)
 
+        if self._block_boundary_updater is None:
+            pass
+        else:
+            x0: np.ndarray = self.get_x0()
+
+            # Procedural outputs such as sampled modes and saturations are
+            # retained runtime parameters. Their startup value must come from
+            # evaluating the procedural logic on the initialized operating
+            # point, not only from the generic mode_dict seed.
+            self._block_boundary_updater.initialize_modes(float(t0), x0, self._event_params_values)
+
     def emt_boundary_update(
             self,
             t_curr: float,

{veragridengine-6.2.4 → veragridengine-6.2.6}/VeraGridEngine/Simulations/results_template.py

@@ -176,7 +176,7 @@ class ResultsTemplate(metaclass=ResultsTemplateMeta):
         return type(self).CLASS_DATA_VARIABLES
 
     @property
-    def time_array(self) -> DateVec:
+    def time_array(self) -> DateVec | None:
         """
         Array of time steps
         :return:

{veragridengine-6.2.4 → veragridengine-6.2.6}/VeraGridEngine/Utils/procedural_logic.py

@@ -3064,6 +3064,31 @@ class BlockProceduralLogicUpdater(BoundaryUpdateWrapper):
         for logic in self.logic_entries:
             logic.update(t, x, params)
 
+    def initialize_modes(self, t: float, x: Vec, params: Vec) -> None:
+        """
+        Initialize retained procedural mode outputs at startup.
+
+        The generic EMT runtime-parameter initialization seeds ``mode_dict``
+        values before the procedural layer is active. For procedural outputs such
+        as sampled values and saturations, the correct startup value is the
+        value produced by the procedural logic itself when evaluated at the
+        initialized operating point. This startup pass applies the same update
+        logic once after the continuous initialization has populated the state,
+        algebraic, and differential guesses, so retained mode outputs start from
+        the exact operating-point sample that the runtime layer will hold.
+
+        :param t: Startup simulation time.
+        :param x: Initialized state/algebraic vector.
+        :param params: Runtime parameter vector updated in place.
+        :return: None
+        """
+        logic: ProceduralLogicBase
+
+        # Reuse each logic object's update rule so startup mode seeding matches
+        # the runtime semantics of that procedural block exactly.
+        for logic in self.logic_entries:
+            logic.update(t, x, params)
+
     def get_next_forced_event_time(self, t_prev: float, t_target: float) -> Optional[float]:
         """
         Return the earliest forced event requested by any procedural logic entry.

{veragridengine-6.2.4 → veragridengine-6.2.6}/VeraGridEngine/__version__.py

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

{veragridengine-6.2.4 → veragridengine-6.2.6}/setup.py

@@ -10,31 +10,44 @@ https://github.com/pypa/sampleproject
 """
 
 # Always prefer setuptools over distutils
+import ast
+from pathlib import Path
 from setuptools import setup, find_packages
-import os
-from VeraGridEngine.__version__ import __VeraGridEngine_VERSION__
 
-here = os.path.abspath(os.path.dirname(__file__))
+description = 'VeraGrid is a Power Systems simulation program intended for professional use and research'
 
-long_description = """# VeraGrid
 
-This software aims to be a complete platform for power systems research and simulation.
+def read_module_constant(module_path: Path, constant_name: str) -> str:
+    module_ast = ast.parse(module_path.read_text(encoding='utf-8'), filename=str(module_path))
 
-[Watch the video https](https://youtu.be/SY66WgLGo54)
+    for node in module_ast.body:
+        if isinstance(node, ast.Assign):
+            for target in node.targets:
+                if isinstance(target, ast.Name) and target.id == constant_name:
+                    return str(ast.literal_eval(node.value))
 
-[Check out the documentation](https://veragrid.readthedocs.io)
+    raise ValueError(f"Constant {constant_name!r} not found in {module_path}")
 
 
-## Installation
+def read_long_description() -> str:
+    src_root = Path(__file__).resolve().parent
 
-pip install VeraGridEngine
+    for candidate in (
+        src_root / 'README.md',
+        src_root.parent / 'README.md',
+        src_root.parent.parent / 'README.md',
+    ):
+        if candidate.exists():
+            return candidate.read_text(encoding='utf-8')
 
-For more options (including a standalone setup one), follow the
-[installation instructions]( https://veragrid.readthedocs.io/en/latest/getting_started/install.html)
-from the project's [documentation](https://veragrid.readthedocs.io)
-"""
+    raise FileNotFoundError('README.md not found next to setup.py or in its parent folders')
 
-description = 'VeraGrid is a Power Systems simulation program intended for professional use and research'
+
+long_description = read_long_description()
+__VeraGridEngine_VERSION__ = read_module_constant(
+    Path(__file__).resolve().parent / '__version__.py',
+    '__VeraGridEngine_VERSION__',
+)
 
 pkgs_to_exclude = ['docs', 'research', 'tests', 'tutorials', 'VeraGrid']