VeraGridEngine 6.4.4__tar.gz → 6.4.6__tar.gz

{veragridengine-6.4.4 → veragridengine-6.4.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VeraGridEngine
-Version: 6.4.4
+Version: 6.4.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.4.4 → veragridengine-6.4.6}/VeraGridEngine/Compilers/Gslv/Simulations/investments.py

@@ -4,32 +4,21 @@
 # SPDX-License-Identifier: MPL-2.0
 from __future__ import annotations
 
-from VeraGridEngine.Compilers.Gslv.activation import pg
-from VeraGridEngine.Devices.multi_circuit import MultiCircuit
-from VeraGridEngine.basic_structures import (
-    IntVec,
-    Logger,
-)
-from VeraGridEngine.enumerations import (
-    InvestmentEvaluationMethod,
-    InvestmentsEvaluationObjectives,
-)
 import numpy as np
 import time
-from typing import TYPE_CHECKING
+from VeraGridEngine.Compilers.Gslv.activation import pg
 from VeraGridEngine.Compilers.Gslv.conversion import to_gslv
 from VeraGridEngine.Compilers.Gslv.Simulations.power_flow import get_gslv_pf_options
 from VeraGridEngine.Compilers.Gslv.Simulations.opf import get_gslv_opf_options
+from VeraGridEngine.Devices.multi_circuit import MultiCircuit
+from VeraGridEngine.basic_structures import IntVec, Logger
+from VeraGridEngine.enumerations import InvestmentEvaluationMethod, InvestmentsEvaluationObjectives
 from VeraGridEngine.Simulations.InvestmentsEvaluation.investments_evaluation_results import InvestmentsEvaluationResults
-
-if TYPE_CHECKING:
-    from VeraGridEngine.Simulations.InvestmentsEvaluation.investments_evaluation_options import (
-        InvestmentsEvaluationOptions,
-    )
+from VeraGridEngine.Simulations.InvestmentsEvaluation.investments_evaluation_options import InvestmentsEvaluationOptions
 
 
 def get_gslv_investments_evaluation_options(
-        opt: "InvestmentsEvaluationOptions",
+        opt: InvestmentsEvaluationOptions,
         circuit: MultiCircuit,
         gslv_circuit: "pg.MultiCircuit",
 ) -> "pg.InvestmentsEvaluationOptions":
@@ -68,6 +57,7 @@ def get_gslv_investments_evaluation_options(
         opf_options=get_gslv_opf_options(opt.opf_options, circuit=circuit, gslv_circuit=gslv_circuit),
     )
 
+
 def translate_gslv_investments_evaluation_results(
         res: "pg.InvestmentsEvaluationResults",
 ) -> InvestmentsEvaluationResults:
@@ -93,9 +83,10 @@ def translate_gslv_investments_evaluation_results(
 
     return results
 
+
 def gslv_investments_evaluation(
         circuit: MultiCircuit,
-        options: "InvestmentsEvaluationOptions",
+        options: InvestmentsEvaluationOptions,
         logger: Logger = Logger(),
 ) -> InvestmentsEvaluationResults:
     """

veragridengine-6.4.6/VeraGridEngine/Compilers/Gslv/__init__.py

@@ -0,0 +1,61 @@
+# 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
+# from VeraGridEngine.Compilers.Gslv.activation import (
+#     GSLV_AVAILABLE,
+#     GSLV_RECOMMENDED_VERSION,
+#     GSLV_VERSION,
+#     pg,
+# )
+# from VeraGridEngine.Compilers.Gslv.conversion import to_gslv
+# from VeraGridEngine.Compilers.Gslv.compare import (
+#     CheckArr,
+#     CheckArrEq,
+#     compare_branch_parent_data,
+#     compare_nc,
+#     convert_arr,
+#     convert_gslv_arr_to_idx,
+# )
+# from VeraGridEngine.Compilers.Gslv.Simulations.contingencies import (
+#     gslv_contingencies_snapshot,
+#     gslv_contingencies_ts,
+# )
+# from VeraGridEngine.Compilers.Gslv.Simulations.investments import (
+#     gslv_investments_evaluation,
+# )
+# from VeraGridEngine.Compilers.Gslv.Simulations.linear import gslv_linear_matrices
+# from VeraGridEngine.Compilers.Gslv.Simulations.opf import get_gslv_opf_options, gslv_opf
+# from VeraGridEngine.Compilers.Gslv.Simulations.power_flow import (
+#     get_gslv_pf_options,
+#     gslv_pf,
+#     translate_gslv_pf_results,
+#     translate_gslv_pf_time_series_results,
+# )
+#
+# __all__ = [
+#     "pg",
+#     "GSLV_AVAILABLE",
+#     "GSLV_RECOMMENDED_VERSION",
+#     "GSLV_VERSION",
+#     "to_gslv",
+#     "CheckArr",
+#     "CheckArrEq",
+#     "compare_branch_parent_data",
+#     "compare_nc",
+#     "convert_arr",
+#     "convert_gslv_arr_to_idx",
+#     "gslv_contingencies_snapshot",
+#     "gslv_contingencies_ts",
+#     "get_gslv_investments_evaluation_options",
+#     "gslv_investments_evaluation",
+#     "translate_gslv_investments_evaluation_results",
+#     "gslv_linear_matrices",
+#     "get_gslv_opf_options",
+#     "gslv_opf",
+#     "get_gslv_pf_options",
+#     "gslv_pf",
+#     "translate_gslv_pf_results",
+#     "translate_gslv_pf_time_series_results",
+# ]

{veragridengine-6.4.4 → veragridengine-6.4.6}/VeraGridEngine/Devices/Dynamic/var_factory.py

@@ -20,6 +20,63 @@ def _new_uid() -> int:
     """
     return uuid.uuid4().int
 
+
+def find_var_by_persisted_identity(var_dict: Dict[int, Var],
+                                   persisted_uid: int | None) -> Var | None:
+    """
+    Resolve a variable from either stable identity or legacy mutable UID.
+
+    :param var_dict: Variable dictionary keyed by stable identity.
+    :param persisted_uid: Identifier read from a persisted property.
+    :return: Matching variable or ``None``.
+    """
+    direct_var: Var | None
+    candidate_var: Var
+
+    if persisted_uid is None:
+        return None
+    else:
+        direct_var = var_dict.get(persisted_uid, None)
+
+    if direct_var is not None:
+        return direct_var
+    else:
+        pass
+
+    # Files written before stable references were used store the mutable UID.
+    # Keep that format readable while all new writes use non_mutable_uid.
+    for candidate_var in var_dict.values():
+        if candidate_var.uid == persisted_uid:
+            return candidate_var
+        else:
+            pass
+
+    return None
+
+
+def build_persisted_identity_lookup(var_dict: Dict[int, Var]) -> Dict[int, Var]:
+    """
+    Build one constant-time lookup for stable and legacy mutable identities.
+
+    Stable dictionary keys remain authoritative when a mutable UID collides
+    with another variable's stable identity. This preserves the current
+    connection semantics while avoiding a full dictionary scan for every
+    symbolic leaf in legacy expression archives.
+
+    :param var_dict: Variables keyed by their stable non-mutable identity.
+    :return: Lookup containing stable identities and non-conflicting mutable UID aliases.
+    """
+    identity_lookup: Dict[int, Var] = dict(var_dict)
+    candidate_var: Var
+
+    for candidate_var in var_dict.values():
+        if candidate_var.uid not in identity_lookup:
+            identity_lookup[candidate_var.uid] = candidate_var
+        else:
+            pass
+
+    return identity_lookup
+
 class Connection:
     """
     Lightweight saved description of one propagated variable connection.
@@ -150,7 +207,8 @@ class VarFactory(EditableDevice):
             self._var_dict[v.non_mutable_uid] = v
             return v
         else:
-            v = Var(name=name, reference=reference, network_conn=network_conn, shared_reference=shared_reference, uid=uid,
+            v = Var(name=name, reference=reference, network_conn=network_conn,
+                    shared_reference=shared_reference, non_mutable_uid=non_mutable_uid, uid=uid,
                     diff_var=None, base_var=None)
             if shared_reference is not None:
                 self.save_var_in_vars_references_dict(v, shared_reference.name)
@@ -188,7 +246,16 @@ class VarFactory(EditableDevice):
         :return:
         """
         if uid is not None:
-            return self._var_dict[uid]
+            found_var: Var | None = find_var_by_persisted_identity(
+                var_dict=self._var_dict,
+                persisted_uid=uid,
+            )
+            if found_var is not None:
+                return found_var
+            else:
+                # Preserve the historical KeyError contract for truly missing
+                # variable references after both lookup formats are exhausted.
+                return self._var_dict[uid]
         else:
             return None
 
@@ -217,23 +284,84 @@ class VarFactory(EditableDevice):
                 self.create_reference(shared_reference)
                 self._vars_references_dict[self._references_dict[shared_reference].uid] = list()
 
-            v = Var(name=name, shared_reference=self._references_dict[shared_reference], reference=reference, network_conn=network_conn, uid=uid, diff_var=diff_var, base_var=base_var)
+            v = Var(name=name, shared_reference=self._references_dict[shared_reference], reference=reference,
+                    network_conn=network_conn, non_mutable_uid=non_mutable_uid, uid=uid,
+                    diff_var=diff_var, base_var=base_var)
             self.save_var_in_vars_references_dict(v, shared_reference)
             self._var_dict[v.non_mutable_uid] = v
             self._diff_var_dict[v.non_mutable_uid] = v
             return v
         else:
-            v = Var(name=name, reference=reference, network_conn=network_conn, shared_reference=shared_reference, uid=uid, diff_var=diff_var, base_var=base_var)
+            v = Var(name=name, reference=reference, network_conn=network_conn,
+                    shared_reference=shared_reference, non_mutable_uid=non_mutable_uid, uid=uid,
+                    diff_var=diff_var, base_var=base_var)
             self._diff_var_dict[v.non_mutable_uid] = v
             return v
 
+    def get_connection_source_non_mutable_uid(self,
+                                              variable_non_mutable_uid: int) -> int:
+        """
+        Resolve the upstream owner of one connected variable identity.
+
+        The saved connection graph is directional from an incoming source to
+        substituted targets. A rename can originate from either endpoint in
+        the editor, so it must first walk the reverse relation and then replay
+        the existing forward propagation from the canonical source.
+
+        :param variable_non_mutable_uid: Stable identity selected by the user.
+        :return: Stable identity of the upstream connection owner.
+        """
+        current_non_mutable_uid: int = variable_non_mutable_uid
+        visited_non_mutable_uids: set[int] = set()
+        source_non_mutable_uid: int | None
+        owner_non_mutable_uid: int
+        connection_list: List[Connection]
+        connection: Connection
+
+        while current_non_mutable_uid not in visited_non_mutable_uids:
+            visited_non_mutable_uids.add(current_non_mutable_uid)
+            source_non_mutable_uid = None
+
+            # Find the unique incoming owner without changing the established
+            # source-to-target storage layout used by connect/disconnect.
+            for owner_non_mutable_uid, connection_list in self._vars_connected_dict.items():
+                for connection in connection_list:
+                    if connection.non_mutable_uid == current_non_mutable_uid:
+                        source_non_mutable_uid = owner_non_mutable_uid
+                        break
+                    else:
+                        pass
+
+                if source_non_mutable_uid is not None:
+                    break
+                else:
+                    pass
+
+            if source_non_mutable_uid is None:
+                return current_non_mutable_uid
+            else:
+                current_non_mutable_uid = source_non_mutable_uid
+
+        # A malformed cycle has no unique root. Returning the first repeated
+        # identity keeps rename propagation finite and consistent with the
+        # existing cycle guard in connect_variables_by_uid().
+        return current_non_mutable_uid
+
     def get_diff_var(self, uid: int) -> Var:
         """
         Gets a Diff Var from the class
         :param uid:
         :return:
         """
-        return self._diff_var_dict[uid]
+        found_var: Var | None = find_var_by_persisted_identity(
+            var_dict=self._diff_var_dict,
+            persisted_uid=uid,
+        )
+        if found_var is not None:
+            return found_var
+        else:
+            # Preserve the historical KeyError for a genuinely absent entry.
+            return self._diff_var_dict[uid]
 
     def add_const(self,
                   value: float | None = None,
@@ -305,14 +433,38 @@ class VarFactory(EditableDevice):
         else:
             pass
 
-    def add_connection(self, var_to_subs: Var, incoming_var: Var):
+    def add_connection(self, var_to_subs: Var, incoming_var: Var) -> None:
+        """
+        Register and propagate one directed symbolic-variable connection.
+
+        Reopening an editor and running dynamic preflight can request the same
+        bus-to-device edge repeatedly. Keep one restoration record per stable
+        target while still replaying the current incoming UID and name.
+
+        :param var_to_subs: Target variable whose effective identity is replaced.
+        :param incoming_var: Source variable providing the effective identity.
+        :return: None.
+        """
+        connections: List[Connection]
+        existing_connection: Connection
 
-        if not incoming_var.non_mutable_uid in self._vars_connected_dict:
+        if incoming_var.non_mutable_uid not in self._vars_connected_dict:
             self._vars_connected_dict[incoming_var.non_mutable_uid] = list()
+        else:
+            pass
 
-        connection = Connection(var_to_subs.non_mutable_uid, var_to_subs.name, var_to_subs.uid)
-        self._vars_connected_dict[incoming_var.non_mutable_uid].append(connection)
+        connections = self._vars_connected_dict[incoming_var.non_mutable_uid]
+        for existing_connection in connections:
+            if existing_connection.non_mutable_uid == var_to_subs.non_mutable_uid:
+                self.connect_variables_by_uid(var_to_subs.non_mutable_uid,
+                                              incoming_var.uid,
+                                              incoming_var.name)
+                return
+            else:
+                pass
 
+        connection = Connection(var_to_subs.non_mutable_uid, var_to_subs.name, var_to_subs.uid)
+        connections.append(connection)
         self.connect_variables_by_uid(connection.non_mutable_uid, incoming_var.uid, incoming_var.name)
 
     def remove_connection(self, var_to_disconnect: Var, outgoing_var: Var) -> None:
@@ -558,7 +710,7 @@ class VarFactory(EditableDevice):
         :param data_list: Serialized differential variable records.
         :return: None.
         """
-        obj_dict: Dict[int, Var | Const | Var] = dict()
+        obj_dict: Dict[int, Var] = dict()
         for data in data_list:
             data_tpe: Any = data.get("type", None)
             if data_tpe != "DiffVar":
@@ -578,14 +730,29 @@ class VarFactory(EditableDevice):
             # are linked to the already reconstructed algebraic/differential
             # chain. This preserves the original derivative hierarchy.
             base_var_uid: Any = data.get("base_var", None)
-            if base_var_uid in self._var_dict.keys():
-                base_var = self._var_dict[base_var_uid]
-            elif base_var_uid in self._diff_var_dict.keys():
-                base_var = self._diff_var_dict[base_var_uid]
-            elif base_var_uid in obj_dict.keys():
-                base_var = obj_dict[base_var_uid]
+            base_var: Var | None = find_var_by_persisted_identity(
+                var_dict=self._var_dict,
+                persisted_uid=base_var_uid,
+            )
+            if base_var is None:
+                base_var = find_var_by_persisted_identity(
+                    var_dict=self._diff_var_dict,
+                    persisted_uid=base_var_uid,
+                )
+            else:
+                pass
+            if base_var is None:
+                base_var = find_var_by_persisted_identity(
+                    var_dict=obj_dict,
+                    persisted_uid=base_var_uid,
+                )
             else:
+                pass
+
+            if base_var is None:
                 continue
+            else:
+                pass
 
             # Older persisted symbolic models may not store the power-flow
             # reference field on differential variables either.
@@ -633,6 +800,7 @@ class VarFactory(EditableDevice):
 
             obj = Var(name=obj_name,
                       uid=obj_uid,
+                      non_mutable_uid=data.get("non_mutable_uid", obj_uid),
                       base_var=base_var,
                       shared_reference=key_ref,
                       reference=reference_power_flow)

{veragridengine-6.4.4 → veragridengine-6.4.6}/VeraGridEngine/Devices/Fluid/fluid_injection_template.py

@@ -72,7 +72,7 @@ class FluidInjectionTemplate(PhysicalDevice):
             tpe=DeviceType.FacilityDevice,
             definition='Facility where this is located',
             editable=True,
-            cat=[PrpCat.OPF],
+            cat=[PrpCat.OPF, PrpCat.TP],
         ),
     )
 

{veragridengine-6.4.4 → veragridengine-6.4.6}/VeraGridEngine/Devices/Parents/branch_parent.py

@@ -180,6 +180,7 @@ class BranchParent(DynamicDevice):
             tpe=str,
             definition='Color to paint the element in the map diagram',
             is_color=True,
+            cat=[PrpCat.TP],
         ),
         GCProp(
             prop_name='bus_from_pos',

{veragridengine-6.4.4 → veragridengine-6.4.6}/VeraGridEngine/Devices/Parents/injection_parent.py

@@ -78,6 +78,7 @@ class InjectionParent(DynamicDevice):
             tpe=str,
             definition='Color to paint the element in the map diagram',
             is_color=True,
+            cat=[PrpCat.TP],
         ),
         GCProp(
             prop_name='mttf',
@@ -113,7 +114,7 @@ class InjectionParent(DynamicDevice):
             tpe=float,
             definition='Cost of not served energy. Used in OPF.',
             profile_name='Cost_prof',
-            cat=[PrpCat.OPF],
+            cat=[PrpCat.OPF, PrpCat.NTC],
         ),
         GCProp(
             prop_name='facility',
@@ -121,6 +122,7 @@ class InjectionParent(DynamicDevice):
             tpe=DeviceType.FacilityDevice,
             definition='Facility where this is located',
             editable=True,
+            cat=[PrpCat.OPF, PrpCat.TP],
         ),
         GCProp(
             prop_name='technologies',
@@ -166,7 +168,7 @@ class InjectionParent(DynamicDevice):
             units='',
             tpe=bool,
             definition='Consider the injections in kW and kVAr?',
-            cat=[PrpCat.PF, PrpCat.OPF],
+            cat=[PrpCat.PF, PrpCat.OPF, PrpCat.NTC],
         ),
         GCProp(
             prop_name='conn',

{veragridengine-6.4.4 → veragridengine-6.4.6}/VeraGridEngine/Devices/Parents/load_parent.py

@@ -47,7 +47,7 @@ class LoadParent(InjectionParent):
             tpe=float,
             definition='Active power',
             profile_name='P_prof',
-            cat=[PrpCat.PF],
+            cat=[PrpCat.PF, PrpCat.OPF, PrpCat.NTC],
             dyn_ref=ParamPowerFlowReferenceType.Pl0,
         ),
         GCProp(
@@ -56,7 +56,7 @@ class LoadParent(InjectionParent):
             tpe=float,
             definition='Phase A active power',
             profile_name='Pa_prof',
-            cat=[PrpCat.PF3],
+            cat=[PrpCat.PF3, PrpCat.EMT],
             dyn_ref=ParamPowerFlowReferenceType.Pl0_A,
         ),
         GCProp(
@@ -65,7 +65,7 @@ class LoadParent(InjectionParent):
             tpe=float,
             definition='Phase B active power',
             profile_name='Pb_prof',
-            cat=[PrpCat.PF3],
+            cat=[PrpCat.PF3, PrpCat.EMT],
             dyn_ref=ParamPowerFlowReferenceType.Pl0_B,
         ),
         GCProp(
@@ -74,7 +74,7 @@ class LoadParent(InjectionParent):
             tpe=float,
             definition='Phase C active power',
             profile_name='Pc_prof',
-            cat=[PrpCat.PF3],
+            cat=[PrpCat.PF3, PrpCat.EMT],
             dyn_ref=ParamPowerFlowReferenceType.Pl0_C,
         ),
         GCProp(
@@ -83,7 +83,7 @@ class LoadParent(InjectionParent):
             tpe=float,
             definition='Reactive power',
             profile_name='Q_prof',
-            cat=[PrpCat.PF],
+            cat=[PrpCat.PF, PrpCat.OPF, PrpCat.NTC],
             dyn_ref=ParamPowerFlowReferenceType.Ql0,
         ),
         GCProp(
@@ -101,7 +101,7 @@ class LoadParent(InjectionParent):
             tpe=float,
             definition='Phase B reactive power',
             profile_name='Qb_prof',
-            cat=[PrpCat.PF3],
+            cat=[PrpCat.PF3, PrpCat.EMT],
             dyn_ref=ParamPowerFlowReferenceType.Ql0_B,
         ),
         GCProp(
@@ -110,7 +110,7 @@ class LoadParent(InjectionParent):
             tpe=float,
             definition='Phase C reactive power',
             profile_name='Qc_prof',
-            cat=[PrpCat.PF3],
+            cat=[PrpCat.PF3, PrpCat.EMT],
             dyn_ref=ParamPowerFlowReferenceType.Ql0_C,
         ),
     )

{veragridengine-6.4.4 → veragridengine-6.4.6}/VeraGridEngine/Devices/Parents/pointer_device_parent.py

@@ -5,7 +5,7 @@
 from __future__ import annotations
 
 from typing import Union, Tuple, TYPE_CHECKING
-from VeraGridEngine.Devices.Parents.editable_device import EditableDevice, GCProp
+from VeraGridEngine.Devices.Parents.editable_device import EditableDevice, GCProp, PrpCat
 from VeraGridEngine.enumerations import DeviceType
 
 if TYPE_CHECKING:
@@ -32,6 +32,7 @@ class PointerDeviceParent(EditableDevice):
             tpe=str,
             definition='Unique ID',
             editable=False,
+            cat=[PrpCat.TP],
         ),
         GCProp(
             prop_name='tpe',
@@ -39,6 +40,7 @@ class PointerDeviceParent(EditableDevice):
             tpe=DeviceType,
             definition='Device type',
             editable=False,
+            cat=[PrpCat.TP],
         ),
         GCProp(
             prop_name='device_name',
@@ -46,6 +48,7 @@ class PointerDeviceParent(EditableDevice):
             tpe=str,
             definition='Device name',
             editable=False,
+            cat=[PrpCat.TP],
         ),
     )
 

{veragridengine-6.4.4 → veragridengine-6.4.6}/VeraGridEngine/IO/raw/psse_circuit.py

@@ -140,6 +140,10 @@ class PsseCircuit(RawObject, BaseCircuit):
         elif len(data) == 3:
             self.IC, self.SBASE, self.REV = data
             logger.add_warning("RAW header contains 3 elements instead of the expected 6")
+        elif len(data) == 2:
+            self.IC, self.SBASE = data
+            self.REV = 25
+            logger.add_warning("RAW header contains elements instead of the expected 6")
         else:
             logger.add_warning(f"RAW header contains {len(data)} elements instead of the expected 6")
 

{veragridengine-6.4.4 → veragridengine-6.4.6}/VeraGridEngine/IO/raw/raw_parser_writer.py

@@ -266,7 +266,10 @@ def interpret_line(raw_line: str, splitter=','):
     pattern = splitter + r"\s*(?=(?:[^']*'[^']*')*[^']*$)"
 
     # Use re.split to apply the pattern
-    elms = re.split(pattern, lne)
+    if ',' in lne:
+        elms = re.split(pattern, lne)
+    else:
+        elms = lne.split()
 
     for elm in elms:
 
@@ -867,13 +870,21 @@ def read_raw(filename, text_func=None, progress_func=None, logger=Logger()) -> P
                         if is_3w(lines[l_count], bus_set):
                             # 3 - windings (5 lines)
                             for k in range(5):
-                                data.append(lines[l_count])
-                                l_count += 1
+                                try:
+                                    data.append(lines[l_count])
+                                    l_count += 1
+                                except IndexError:
+                                    logger.add_error("Incomplete 3W transformer data at the raw file")
+                                    data = list()
                         else:
                             # 2-windings (4 lines)
                             for k in range(4):
-                                data.append(lines[l_count])
-                                l_count += 1
+                                try:
+                                    data.append(lines[l_count])
+                                    l_count += 1
+                                except IndexError:
+                                    logger.add_error("Incomplete 2W transformer data at the raw file")
+                                    data = list()
 
                     elif key == 'induction machine':
                         if is_one_line_for_induction_machine(lines[l_count]):
@@ -911,10 +922,11 @@ def read_raw(filename, text_func=None, progress_func=None, logger=Logger()) -> P
                     # data = [interpret_line(object_lines[k]) for k in range(lines_per_object)]
 
                     # pass the data to the according object to assign it to the matching variables
-                    data2 = format_lines(data1=data, logger=logger)
-                    obj = ObjectT()
-                    obj.parse(data2, version, logger)
-                    objects_list.append(obj)
+                    if len(data) > 0:
+                        data2 = format_lines(data1=data, logger=logger)
+                        obj = ObjectT()
+                        obj.parse(data2, version, logger)
+                        objects_list.append(obj)
 
                     if progress_func is not None:
                         progress_func((l_count / len(lines)) * 100)

{veragridengine-6.4.4 → veragridengine-6.4.6}/VeraGridEngine/IO/veragrid/pack_unpack.py

@@ -719,7 +719,9 @@ def veragrid_object_to_json(elm: ALL_DEV_TYPES,
 
         elif prop.tpe == SubObjectType.VarType:
             if obj is not None:
-                data[name] = obj.uid
+                # Persist the physical variable identity. The mutable UID can
+                # be shared by every variable connected to the same signal.
+                data[name] = obj.non_mutable_uid
             else:
                 # Persistent dynamic plot entries may keep unresolved legacy Var
                 # hints as ``None`` while semantic fields remain the canonical
@@ -1867,8 +1869,11 @@ def parse_veragrid_data(data: VERAGRID_FILE_TYPE,
             block_parser.parse_diff_vars(symbolic_data["diff_vars"])
             if "connections" in symbolic_data:
                 block_parser.parse_connections(symbolic_data["connections"])
-            for block_uid in symbolic_data["main_block_uids"]:
-                block_parser.parse_block(symbolic_data["blocks"], block_uid)
+            # BlockParser owns compatibility with all historical dynamics
+            # containers, including list-based tables, inline children and
+            # archives created before main_block_uids existed.
+            block_parser.parse_blocks(blocks_data=symbolic_data.get("blocks", dict()),
+                                      main_block_uids=symbolic_data.get("main_block_uids", None))
         else:
             pass  # the symbolic data is empty
     else:

veragridengine-6.4.6/VeraGridEngine/Simulations/InvestmentsEvaluation/Problems/__init__.py

@@ -0,0 +1,10 @@
+# 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 VeraGridEngine.Simulations.InvestmentsEvaluation.Problems.adequacy_problem import AdequacyInvestmentProblem
+from VeraGridEngine.Simulations.InvestmentsEvaluation.Problems.black_box_problem_template import BlackBoxProblemTemplate
+from VeraGridEngine.Simulations.InvestmentsEvaluation.Problems.linear_opf_ts_problem import TimeSeriesLinearOptimalPowerFlowInvestmentProblem
+from VeraGridEngine.Simulations.InvestmentsEvaluation.Problems.power_flow_problem import PowerFlowInvestmentProblem
+from VeraGridEngine.Simulations.InvestmentsEvaluation.Problems.power_flow_ts_problem import TimeSeriesPowerFlowInvestmentProblem

{veragridengine-6.4.4 → veragridengine-6.4.6}/VeraGridEngine/Simulations/InvestmentsEvaluation/__init__.py

@@ -3,5 +3,7 @@
 # file, You can obtain one at https://mozilla.org/MPL/2.0/.
 # SPDX-License-Identifier: MPL-2.0
 
-from VeraGridEngine.Simulations.InvestmentsEvaluation.investments_evaluation_results import InvestmentsEvaluationResults
+# from VeraGridEngine.Simulations.InvestmentsEvaluation.investments_evaluation_results import InvestmentsEvaluationResults
 from VeraGridEngine.Simulations.InvestmentsEvaluation.investments_evaluation_options import InvestmentsEvaluationOptions
+from VeraGridEngine.Simulations.InvestmentsEvaluation.investments_evaluation_driver import InvestmentsEvaluationDriver
+from VeraGridEngine.Simulations.InvestmentsEvaluation.Problems import *