GridCalEngine 5.3.39__tar.gz → 5.3.40__tar.gz

{gridcalengine-5.3.39 → gridcalengine-5.3.40}/GridCalEngine/Compilers/circuit_to_gslv.py

@@ -3,28 +3,30 @@
 # file, You can obtain one at https://mozilla.org/MPL/2.0/.
 # SPDX-License-Identifier: MPL-2.0
 from __future__ import annotations
-import os.path
 import time
-import warnings
 import numpy as np
 from typing import List, Dict, Union, Tuple, TYPE_CHECKING
 
-from GridCalEngine import TapModuleControl, TapPhaseControl, BusMode
+from GridCalEngine.Utils.ThirdParty.gslv.gslv_activation import (pg, build_status_dict, tap_module_control_mode_dict,
+                                                                 tap_phase_control_mode_dict, hvdc_control_mode_dict,
+                                                                 group_type_dict, contingency_ops_type_dict,
+                                                                 contingency_method_dict, converter_control_type_dict,
+                                                                 bus_type_dict,
+                                                                 GSLV_AVAILABLE, GSLV_VERSION,
+                                                                 GSLV_RECOMMENDED_VERSION)
 from GridCalEngine.DataStructures.branch_parent_data import BranchParentData
 from GridCalEngine.basic_structures import IntVec, Vec
 from GridCalEngine.Devices.profile import Profile
 from GridCalEngine.Devices.multi_circuit import MultiCircuit
-from GridCalEngine.enumerations import (HvdcControlType, SolverType, TimeGrouping,
-                                        ZonalGrouping, MIPSolvers, ContingencyMethod, ContingencyOperationTypes,
-                                        BuildStatus, BranchGroupTypes, ConverterControlType)
 import GridCalEngine.Devices as dev
 from GridCalEngine.Simulations.PowerFlow.power_flow_options import PowerFlowOptions
 from GridCalEngine.Simulations.PowerFlow.power_flow_results import PowerFlowResults
-
+from GridCalEngine import TapModuleControl, TapPhaseControl
+from GridCalEngine.enumerations import SolverType
 from GridCalEngine.DataStructures.numerical_circuit import NumericalCircuit
 
-from GridCalEngine.IO.file_system import get_create_gridcal_folder
-from GridCalEngine.basic_structures import ConvergenceReport, Logger
+
+from GridCalEngine.basic_structures import Logger
 
 if TYPE_CHECKING:  # Only imports the below statements during type checking
     from GridCalEngine.Simulations.OPF.opf_results import OptimalPowerFlowResults
@@ -33,97 +35,6 @@ if TYPE_CHECKING:  # Only imports the below statements during type checking
     from GridCalEngine.Simulations.ContingencyAnalysis.contingency_analysis_options import ContingencyAnalysisOptions
     from GridCalEngine.Simulations.ContingencyAnalysis.contingency_analysis_results import ContingencyAnalysisResults
 
-GSLV_RECOMMENDED_VERSION = "0.2.0"
-GSLV_VERSION = ''
-GSLV_AVAILABLE = False
-try:
-    import pygslv as pg
-
-    pg.activate(os.path.join(get_create_gridcal_folder(), "license.gslv"), verbose=True)
-
-    # activate
-    if not pg.isLicensed():
-        # license not found
-        GSLV_AVAILABLE = False
-    else:
-        # already activated
-        GSLV_AVAILABLE = True
-        GSLV_VERSION = pg.get_version()
-
-    if GSLV_AVAILABLE:
-        if GSLV_VERSION < GSLV_RECOMMENDED_VERSION:
-            warnings.warn(f"Recommended version for GSLV is {GSLV_RECOMMENDED_VERSION} "
-                          f"instead of {GSLV_VERSION}")
-
-    build_status_dict = {
-        BuildStatus.Planned: pg.BuildStatus.Planned,
-        BuildStatus.Commissioned: pg.BuildStatus.Commissioned,
-        BuildStatus.Candidate: pg.BuildStatus.Candidate,
-        BuildStatus.Decommissioned: pg.BuildStatus.Decommissioned,
-        BuildStatus.PlannedDecommission: pg.BuildStatus.PlannedDecommission,
-    }
-
-    tap_module_control_mode_dict = {
-        TapModuleControl.fixed: pg.TapModuleControl.fixed,
-        TapModuleControl.Qf: pg.TapModuleControl.Qf,
-        TapModuleControl.Qt: pg.TapModuleControl.Qt,
-        TapModuleControl.Vm: pg.TapModuleControl.Vm,
-    }
-
-    tap_phase_control_mode_dict = {
-        TapPhaseControl.fixed: pg.TapPhaseControl.fixed,
-        TapPhaseControl.Pf: pg.TapPhaseControl.Pf,
-        TapPhaseControl.Pt: pg.TapPhaseControl.Pt,
-    }
-
-    hvdc_control_mode_dict = {
-        HvdcControlType.type_0_free: pg.HvdcControlType.type_0_free,
-        HvdcControlType.type_1_Pset: pg.HvdcControlType.type_1_Pset,
-    }
-
-    group_type_dict = {
-        BranchGroupTypes.GenericGroup: pg.BranchGroupTypes.GenericGroup,
-        BranchGroupTypes.TransformerGroup: pg.BranchGroupTypes.TransformerGroup,
-        BranchGroupTypes.LineSegmentsGroup: pg.BranchGroupTypes.LineSegmentsGroup,
-    }
-
-    contingency_ops_type_dict = {
-        ContingencyOperationTypes.Active: pg.ContingencyOperationTypes.Active,
-        ContingencyOperationTypes.PowerPercentage: pg.ContingencyOperationTypes.PowerPercentage,
-    }
-
-    contingency_method_dict = {
-        ContingencyMethod.PTDF: pg.ContingencyMethod.PTDF,
-        ContingencyMethod.PowerFlow: pg.ContingencyMethod.PowerFlow,
-        ContingencyMethod.HELM: pg.ContingencyMethod.HELM,
-    }
-
-    converter_control_type_dict = {
-        ConverterControlType.Vm_dc: pg.ConverterControlType.Vm_dc,
-        ConverterControlType.Vm_ac: pg.ConverterControlType.Vm_ac,
-        ConverterControlType.Va_ac: pg.ConverterControlType.Va_ac,
-        ConverterControlType.Qac: pg.ConverterControlType.Q_ac,
-        ConverterControlType.Pdc: pg.ConverterControlType.P_dc,
-        ConverterControlType.Pac: pg.ConverterControlType.P_ac,
-    }
-
-    bus_type_dict = {
-        BusMode.PQ_tpe.value: pg.BusMode.PQ,
-        BusMode.PV_tpe.value: pg.BusMode.PV,
-        BusMode.Slack_tpe.value: pg.BusMode.Slack,
-        BusMode.P_tpe.value: pg.BusMode.P,
-        BusMode.PQV_tpe.value: pg.BusMode.PQV,
-    }
-
-except ImportError as e:
-    pg = None
-    GSLV_AVAILABLE = False
-    GSLV_VERSION = ''
-    build_status_dict = dict()
-    tap_module_control_mode_dict = dict()
-    tap_phase_control_mode_dict = dict()
-    contingency_ops_type_dict = dict()
-    contingency_method_dict = dict()
 
 
 def get_gslv_mip_solvers_list() -> List[str]:
@@ -2493,10 +2404,10 @@ def translate_gslv_pf_results(grid: MultiCircuit, res: "pg.PowerFlowResults", lo
     results.loading = res.loading[0, :]
     results.losses = res.losses[0, :]
     # results.Vbranch = res.Vbranch[0, :]
-    # results.If = res.If[0, :]
-    # results.It = res.It[0, :]
-    # results.Beq = res.Beq[0, :]
-    results.m = res.tap_module[0, :]
+    results.If = res.If[0, :]
+    results.It = res.It[0, :]
+
+    results.tap_module = res.tap_module[0, :]
     results.tap_angle = res.tap_angle[0, :]
     # results.F = res.F
     # results.T = res.T
@@ -2512,6 +2423,10 @@ def translate_gslv_pf_results(grid: MultiCircuit, res: "pg.PowerFlowResults", lo
     results.loading_vsc = res.loading_vsc[0, :]
     results.losses_vsc = res.losses_vsc[0, :]
 
+    results.gen_q = res.gen_q[0, :]
+    results.battery_q = res.battery_q[0, :]
+    results.shunt_q = res.shunt_q[0, :]
+
     # logger.add_info("gslv time", value=res.time_array[0])
 
     # results.bus_area_indices = grid.get_bus_area_indices()

{gridcalengine-5.3.39 → gridcalengine-5.3.40}/GridCalEngine/IO/cim/cgmes/cgmes_data_parser.py

@@ -167,10 +167,11 @@ def merge(A: Dict[str, Dict[str, Dict[str, str]]],
                                 pass
 
 
-def read_cgmes_files(cim_files: Union[List[str], str]) -> Dict[str, List[str]]:
+def read_cgmes_files(cim_files: Union[List[str], str], logger: DataLogger) -> Dict[str, List[str]]:
     """
     Reads a list of .zip or xml into a dictionary of file name -> list of text lines
     :param cim_files: list of file names
+    :param logger: DataLogger instance
     :return: dictionary of file name -> list of text lines
     """
     # read files and sort them in the preferred reading order
@@ -189,21 +190,28 @@ def read_cgmes_files(cim_files: Union[List[str], str]) -> Dict[str, List[str]]:
             elif file_extension == '.zip':
                 # read the content of a zip file
                 d = get_xml_from_zip(file_name_zip=f)
-                for key, value in d.items():
-                    data[key] = value
+                if d is not None:
+                    for key, value in d.items():
+                        data[key] = value
+                else:
+                    logger.add_error("BadZipFile", value=f)
+                    print(f"BadZipFile {f}")
     else:
         name, file_extension = os.path.splitext(cim_files)
 
         if file_extension == '.xml':
-            file_ptr = open(cim_files, 'rb')
-            data[name] = get_xml_content(file_ptr)
-            file_ptr.close()
+            with open(cim_files, 'rb') as file_ptr:
+                data[name] = get_xml_content(file_ptr=file_ptr)
 
         elif file_extension == '.zip':
             # read the content of a zip file
             d = get_xml_from_zip(file_name_zip=cim_files)
-            for key, value in d.items():
-                data[key] = value
+            if d is not None:
+                for key, value in d.items():
+                    data[key] = value
+            else:
+                logger.add_error("BadZipFile", value=cim_files)
+                print(f"BadZipFile {cim_files}")
 
     return data
 
@@ -324,7 +332,7 @@ class CgmesDataParser(BaseCircuit):
                           "http://iec.ch/TC57/ns/CIM/StateVariables-EU/3.0",
                           "http://iec.ch/TC57/ns/CIM/Topology-EU/3.0"]
         # import the cim files' content into a dictionary
-        data = read_cgmes_files(files)
+        data = read_cgmes_files(cim_files=files, logger=self.logger)
         # Parse the files
         i = 0
         for file_name, file_data in data.items():

{gridcalengine-5.3.39 → gridcalengine-5.3.40}/GridCalEngine/IO/cim/cgmes/cgmes_export.py

@@ -21,6 +21,32 @@ import xml.etree.ElementTree as Et
 import xml.dom.minidom
 
 
+def get_available_cgmes_profiles(cgmes_version: CGMESVersions):
+    if cgmes_version == CGMESVersions.v2_4_15:
+        return {
+            "EQ": ["http://entsoe.eu/CIM/EquipmentCore/3/1",
+                   "http://entsoe.eu/CIM/EquipmentShortCircuit/3/1",
+                   "http://entsoe.eu/CIM/EquipmentOperation/3/1"],
+            "SSH": ["http://entsoe.eu/CIM/SteadyStateHypothesis/1/1"],
+            "TP": ["http://entsoe.eu/CIM/Topology/4/1"],
+            "SV": ["http://entsoe.eu/CIM/StateVariables/4/1"],
+            "GL": ["http://entsoe.eu/CIM/GeographicalLocation/2/1"]
+        }
+    elif cgmes_version == CGMESVersions.v3_0_0:
+        return {
+            "EQ": ["http://iec.ch/TC57/ns/CIM/CoreEquipment-EU/3.0"],
+            "OP": ["http://iec.ch/TC57/ns/CIM/Operation-EU/3.0"],
+            "SC": ["http://iec.ch/TC57/ns/CIM/ShortCircuit-EU/3.0"],
+            "SSH": ["http://iec.ch/TC57/ns/CIM/SteadyStateHypothesis-EU/3.0"],
+            "TP": ["http://iec.ch/TC57/ns/CIM/Topology-EU/3.0"],
+            "SV": ["http://iec.ch/TC57/ns/CIM/StateVariables-EU/3.0"],
+            "GL": ["http://iec.ch/TC57/ns/CIM/GeographicalLocation-EU/3.0"]
+        }
+    else:
+        print(f"CGMES Version not suported {cgmes_version.value}")
+        return dict()
+
+
 class CimExporter:
     def __init__(self, cgmes_circuit: CgmesCircuit, profiles_to_export: List[cgmesProfile], one_file_per_profile: bool):
         self.cgmes_circuit = cgmes_circuit
@@ -48,15 +74,7 @@ class CimExporter:
                 "xmlns:entsoe": "http://entsoe.eu/CIM/SchemaExtension/3/1#",
                 "xmlns:rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
             }
-            self.profile_uris = {
-                "EQ": ["http://entsoe.eu/CIM/EquipmentCore/3/1",
-                       "http://entsoe.eu/CIM/EquipmentShortCircuit/3/1",
-                       "http://entsoe.eu/CIM/EquipmentOperation/3/1"],
-                "SSH": ["http://entsoe.eu/CIM/SteadyStateHypothesis/1/1"],
-                "TP": ["http://entsoe.eu/CIM/Topology/4/1"],
-                "SV": ["http://entsoe.eu/CIM/StateVariables/4/1"],
-                "GL": ["http://entsoe.eu/CIM/GeographicalLocation/2/1"]
-            }
+            self.profile_uris = get_available_cgmes_profiles(cgmes_version=cgmes_circuit.cgmes_version)
 
             self.enum_dict = dict()
             self.about_dict = dict()
@@ -101,15 +119,8 @@ class CimExporter:
                 "xmlns:eu": "http://iec.ch/TC57/CIM100-European#",
                 "xmlns:rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
             }
-            self.profile_uris = {
-                "EQ": ["http://iec.ch/TC57/ns/CIM/CoreEquipment-EU/3.0"],
-                "OP": ["http://iec.ch/TC57/ns/CIM/Operation-EU/3.0"],
-                "SC": ["http://iec.ch/TC57/ns/CIM/ShortCircuit-EU/3.0"],
-                "SSH": ["http://iec.ch/TC57/ns/CIM/SteadyStateHypothesis-EU/3.0"],
-                "TP": ["http://iec.ch/TC57/ns/CIM/Topology-EU/3.0"],
-                "SV": ["http://iec.ch/TC57/ns/CIM/StateVariables-EU/3.0"],
-                "GL": ["http://iec.ch/TC57/ns/CIM/GeographicalLocation-EU/3.0"]
-            }
+            self.profile_uris = get_available_cgmes_profiles(cgmes_version=cgmes_circuit.cgmes_version)
+
             self.enum_dict = dict()
             self.about_dict = dict()
             for s_i, p_i, o_i in rdf_serialization.triples((None, RDF.type, RDFS.Class)):

{gridcalengine-5.3.39 → gridcalengine-5.3.40}/GridCalEngine/IO/cim/cgmes/cgmes_to_gridcal.py

@@ -279,7 +279,7 @@ def get_gcdev_buses(cgmes_model: CgmesCircuit,
                     gc_model: MultiCircuit,
                     v_dict: Dict[str, Tuple[float, float]],
                     cn_look_up: CnLookup,
-                    logger: DataLogger) -> Dict[str, gcdev.Bus]:
+                    logger: DataLogger) -> Tuple[Dict[str, gcdev.Bus], bool]:
     """
     Convert the TopologicalNodes to Buses (CalculationNodes)
 
@@ -289,7 +289,7 @@ def get_gcdev_buses(cgmes_model: CgmesCircuit,
     :param cn_look_up: CnLookup
     :param logger: DataLogger
     :return: dictionary relating the TopologicalNode uuid to the gcdev CalculationNode
-             Dict[str, gcdev.Bus]
+             Dict[str, gcdev.Bus], fatal error?
     """
 
     slack_id = get_slack_id(cgmes_model.cgmes_assets.SynchronousMachine_list)
@@ -310,11 +310,12 @@ def get_gcdev_buses(cgmes_model: CgmesCircuit,
                              device_class=tp_node.tpe,
                              device_property="nominalVoltage")
         elif nominal_voltage is None:
-            logger.add_error(msg='Nominal voltage is None. :(',
+            logger.add_error(msg='Nominal voltage is None. Maybe boundary was not attached for import :(',
                              device=tp_node.rdfid,
                              device_class=tp_node.tpe,
                              device_property="nominalVoltage")
-            raise Exception("Nominal voltage is missing for Bus (Maybe boundary was not attached for import) !")
+            # raise Exception("Nominal voltage is missing for Bus (Maybe boundary was not attached for import) !")
+            return calc_node_dict, True
 
 
         if voltage is not None and nominal_voltage is not None:
@@ -392,7 +393,7 @@ def get_gcdev_buses(cgmes_model: CgmesCircuit,
         cn_look_up.add_bus(bus=gcdev_elm)
         calc_node_dict[gcdev_elm.idtag] = gcdev_elm
 
-    return calc_node_dict
+    return calc_node_dict, False
 
 
 def get_gcdev_dc_buses(cgmes_model: CgmesCircuit,
@@ -2339,11 +2340,14 @@ def cgmes_to_gridcal(cgmes_model: CgmesCircuit,
     device_to_terminal_dict = get_gcdev_device_to_terminal_dict(cgmes_model=cgmes_model,
                                                                 logger=logger)
 
-    calc_node_dict: Dict[str, gcdev.Bus] = get_gcdev_buses(cgmes_model=cgmes_model,
-                                                           gc_model=gc_model,
-                                                           v_dict=sv_volt_dict,
-                                                           cn_look_up=cn_look_up,
-                                                           logger=logger)
+    calc_node_dict, fatal_error = get_gcdev_buses(cgmes_model=cgmes_model,
+                                                   gc_model=gc_model,
+                                                   v_dict=sv_volt_dict,
+                                                   cn_look_up=cn_look_up,
+                                                   logger=logger)
+
+    if fatal_error:
+        return gc_model
 
     cn_dict = get_gcdev_connectivity_nodes(cgmes_model=cgmes_model,
                                            gcdev_model=gc_model,

{gridcalengine-5.3.39 → gridcalengine-5.3.40}/GridCalEngine/IO/cim/cim16/cim_parser.py

@@ -14,7 +14,7 @@ from GridCalEngine.IO.cim.cim16.cim_circuit import CIMCircuit
 from GridCalEngine.data_logger import DataLogger
 
 
-def read_cim_files(cim_files):
+def read_cim_files(cim_files, logger: DataLogger):
     """
     Reads a list of .zip or xml into a dictionary of file name -> list of text lines
     :param cim_files: list of file names
@@ -49,8 +49,13 @@ def read_cim_files(cim_files):
         elif file_extension == '.zip':
             # read the content of a zip file
             d = get_xml_from_zip(file_name_zip=cim_files)
-            for key, value in d.items():
-                data[key] = value
+
+            if d is not None:
+                for key, value in d.items():
+                    data[key] = value
+            else:
+                logger.add_error("BadZipFile", value=cim_files)
+                print(f"BadZipFile {cim_files}")
 
     return data
 
@@ -968,7 +973,7 @@ class CIMImport:
         self.cim = CIMCircuit(text_func=self.text_func, progress_func=self.progress_func, logger=self.logger)
 
         # import the cim files' content into a dictionary
-        data = read_cim_files(cim_files)
+        data = read_cim_files(cim_files=cim_files, logger=self.logger)
 
         lst2 = sort_cim_files(list(data.keys()))
         # Parse the files

{gridcalengine-5.3.39 → gridcalengine-5.3.40}/GridCalEngine/IO/file_handler.py

@@ -417,6 +417,10 @@ class FileOpen:
                         self.circuit = cgmes_to_gridcal(cgmes_model=self.cgmes_circuit,
                                                         map_dc_to_hvdc_line=self.options.try_to_map_dc_to_hvdc_line,
                                                         logger=self.cgmes_logger)
+
+                        if self.cgmes_logger.has_logs():
+                            self.logger += self.cgmes_logger.get_logger()
+
                     else:
                         # try CIM
                         parser = CIMImport(text_func=text_func, progress_func=progress_func)

{gridcalengine-5.3.39 → gridcalengine-5.3.40}/GridCalEngine/IO/gridcal/zip_interface.py

@@ -3,7 +3,7 @@
 # file, You can obtain one at https://mozilla.org/MPL/2.0/.
 # SPDX-License-Identifier: MPL-2.0
 import json
-from io import StringIO, TextIOWrapper, BytesIO
+from io import StringIO, TextIOWrapper, BytesIO, BufferedReader
 import os
 import numpy as np
 import chardet
@@ -435,7 +435,7 @@ def load_session_driver_objects(file_name_zip: str,
     return data
 
 
-def get_xml_content(file_ptr: zipfile.ZipExtFile) -> List[str]:
+def get_xml_content(file_ptr: zipfile.ZipExtFile | BufferedReader) -> List[str]:
     """
     Reads the content of a file
     :param file_ptr: File pointer (from file or zip file)

{gridcalengine-5.3.39 → gridcalengine-5.3.40}/GridCalEngine/Simulations/PowerFlow/Formulations/pf_basic_formulation.py

@@ -236,6 +236,10 @@ class PfBasicFormulation(PfFormulationTemplate):
 
         nbus = self.adm.Ybus.shape[0]
 
+        if self.options.verbose >= 2:
+            print("Ybus:")
+            print(self.adm.Ybus.toarray())
+
         # Create J in CSC order
         J = create_J_vc_csc(nbus, self.adm.Ybus.data, self.adm.Ybus.indptr, self.adm.Ybus.indices,
                             self.V, self.idx_dVa, self.idx_dVm, self.idx_dP, self.idx_dQ)
@@ -287,8 +291,8 @@ class PfBasicFormulation(PfFormulationTemplate):
 
         return NumericPowerFlowResults(V=self.V,
                                        Scalc=Sbus * self.nc.Sbase,
-                                       m=np.ones(self.nc.nbr, dtype=float),
-                                       tau=np.zeros(self.nc.nbr, dtype=float),
+                                       m=self.nc.active_branch_data.tap_module,
+                                       tau=self.nc.active_branch_data.tap_angle,
                                        Sf=Sf,
                                        St=St,
                                        If=If,

{gridcalengine-5.3.39 → gridcalengine-5.3.40}/GridCalEngine/Simulations/PowerFlow/Formulations/pf_generalized_formulation.py

@@ -654,7 +654,7 @@ class PfGeneralizedFormulation(PfFormulationTemplate):
                         u_cbr_m.append(k)
                 else:
                     self.logger.add_error("Controlled bus index outside of the island, skipping control",
-                                          device=self.nc.passive_branch_data.idtag[k],)
+                                          device=self.nc.passive_branch_data.idtag[k], )
 
             elif ctrl_m == TapModuleControl.Qf:
                 u_cbr_m.append(k)
@@ -1197,10 +1197,11 @@ class PfGeneralizedFormulation(PfFormulationTemplate):
                 + len(self.u_cbr_m)
                 + len(self.u_cbr_tau))
 
-    def compute_f(self, x: Vec) -> Vec:
+    def compute_f(self, x: Vec, update_class_vars: bool = False) -> Vec:
         """
         Compute the residual vector
         :param x: Solution vector
+        :param update_class_vars: Update the class vars related to the calculation step
         :return: Residual vector
         """
 
@@ -1219,32 +1220,32 @@ class PfGeneralizedFormulation(PfFormulationTemplate):
         k = j + len(self.u_cbr_tau)
 
         # copy the sliceable vectors
-        Vm = self.Vm.copy()
-        Va = self.Va.copy()
-        Pf_vsc = self.Pf_vsc.copy()
-        Pt_vsc = self.Pt_vsc.copy()
-        Qt_vsc = self.Qt_vsc.copy()
+        Vm_ = self.Vm.copy()
+        Va_ = self.Va.copy()
+        Pf_vsc_ = self.Pf_vsc.copy()
+        Pt_vsc_ = self.Pt_vsc.copy()
+        Qt_vsc_ = self.Qt_vsc.copy()
 
         # update the vectors
-        Va[self.i_u_va] = x[0:a]
-        Vm[self.i_u_vm] = x[a:b]
-        Pf_vsc[self.u_vsc_pf] = x[b:c]
-        Pt_vsc[self.u_vsc_pt] = x[c:d]
-        Qt_vsc[self.u_vsc_qt] = x[d:e]
-        Pf_hvdc = x[e:f]
-        Pt_hvdc = x[f:g]
-        Qf_hvdc = x[g:h]
-        Qt_hvdc = x[h:i]
-        m = x[i:j]
-        tau = x[j:k]
+        Va_[self.i_u_va] = x[0:a]
+        Vm_[self.i_u_vm] = x[a:b]
+        Pf_vsc_[self.u_vsc_pf] = x[b:c]
+        Pt_vsc_[self.u_vsc_pt] = x[c:d]
+        Qt_vsc_[self.u_vsc_qt] = x[d:e]
+        Pf_hvdc_ = x[e:f]
+        Pt_hvdc_ = x[f:g]
+        Qf_hvdc_ = x[g:h]
+        Qt_hvdc_ = x[h:i]
+        m_ = x[i:j]
+        tau_ = x[j:k]
 
         # Controllable branches ----------------------------------------------------------------------------------------
         m2 = self.nc.active_branch_data.tap_module.copy()
         tau2 = self.nc.active_branch_data.tap_angle.copy()
-        m2[self.u_cbr_m] = m
-        tau2[self.u_cbr_tau] = tau
+        m2[self.u_cbr_m] = m_
+        tau2[self.u_cbr_tau] = tau_
 
-        self.adm = compute_admittances(
+        adm_ = compute_admittances(
             R=self.nc.passive_branch_data.R,
             X=self.nc.passive_branch_data.X,
             G=self.nc.passive_branch_data.G,
@@ -1262,9 +1263,9 @@ class PfGeneralizedFormulation(PfFormulationTemplate):
         )
 
         # Passive branches ---------------------------------------------------------------------------------------------
-        V = polar_to_rect(Vm, Va)
-        Sbus = compute_zip_power(self.S0, self.I0, self.Y0, Vm)
-        Scalc_passive = compute_power(self.adm.Ybus, V)
+        V = polar_to_rect(Vm_, Va_)
+        Sbus = compute_zip_power(self.S0, self.I0, self.Y0, Vm_)
+        Scalc_passive = compute_power(adm_.Ybus, V)
 
         Pf_cbr = calcSf(k=self.k_cbr_pf,
                         V=V,
@@ -1320,30 +1321,30 @@ class PfGeneralizedFormulation(PfFormulationTemplate):
 
         # VSC ----------------------------------------------------------------------------------------------------------
         T_vsc = self.nc.vsc_data.T
-        It = np.sqrt(Pt_vsc * Pt_vsc + Qt_vsc * Qt_vsc) / Vm[T_vsc]
+        It = np.sqrt(Pt_vsc_ * Pt_vsc_ + Qt_vsc_ * Qt_vsc_) / Vm_[T_vsc]
         It2 = It * It
         PLoss_IEC = (self.nc.vsc_data.alpha3 * It2
                      + self.nc.vsc_data.alpha2 * It
                      + self.nc.vsc_data.alpha1)
 
-        loss_vsc = PLoss_IEC - Pt_vsc - Pf_vsc
-        St_vsc = make_complex(Pt_vsc, Qt_vsc)
+        loss_vsc = PLoss_IEC - Pt_vsc_ - Pf_vsc_
+        St_vsc = make_complex(Pt_vsc_, Qt_vsc_)
 
         # HVDC ---------------------------------------------------------------------------------------------------------
-        Vmf_hvdc = Vm[self.nc.hvdc_data.F]
+        Vmf_hvdc = Vm_[self.nc.hvdc_data.F]
         zbase = self.nc.hvdc_data.Vnf * self.nc.hvdc_data.Vnf / self.nc.Sbase
-        Ploss_hvdc = self.nc.hvdc_data.r / zbase * np.power(Pf_hvdc / Vmf_hvdc, 2.0)
-        loss_hvdc = Ploss_hvdc - Pf_hvdc - Pt_hvdc
+        Ploss_hvdc = self.nc.hvdc_data.r / zbase * np.power(Pf_hvdc_ / Vmf_hvdc, 2.0)
+        loss_hvdc = Ploss_hvdc - Pf_hvdc_ - Pt_hvdc_
 
         Pinj_hvdc = self.nc.hvdc_data.Pset / self.nc.Sbase
         if len(self.hvdc_droop_idx):
-            Vaf_hvdc = Vm[self.nc.hvdc_data.F[self.hvdc_droop_idx]]
-            Vat_hvdc = Vm[self.nc.hvdc_data.T[self.hvdc_droop_idx]]
+            Vaf_hvdc = Vm_[self.nc.hvdc_data.F[self.hvdc_droop_idx]]
+            Vat_hvdc = Vm_[self.nc.hvdc_data.T[self.hvdc_droop_idx]]
             Pinj_hvdc[self.hvdc_droop_idx] += self.nc.hvdc_data.angle_droop[self.hvdc_droop_idx] * (Vaf_hvdc - Vat_hvdc)
-        inj_hvdc = Pf_hvdc - Pinj_hvdc
+        inj_hvdc = Pf_hvdc_ - Pinj_hvdc
 
-        Sf_hvdc = make_complex(Pf_hvdc, Qf_hvdc)
-        St_hvdc = make_complex(Pt_hvdc, Qt_hvdc)
+        Sf_hvdc = make_complex(Pf_hvdc_, Qf_hvdc_)
+        St_hvdc = make_complex(Pt_hvdc_, Qt_hvdc_)
 
         # total nodal power --------------------------------------------------------------------------------------------
         Scalc_active = calc_flows_active_branch_per_bus(
@@ -1354,15 +1355,15 @@ class PfGeneralizedFormulation(PfFormulationTemplate):
             St_hvdc=St_hvdc,
             F_vsc=self.nc.vsc_data.F,
             T_vsc=self.nc.vsc_data.T,
-            Pf_vsc=Pf_vsc,
+            Pf_vsc=Pf_vsc_,
             St_vsc=St_vsc)
 
-        self.Scalc = Scalc_active + Scalc_passive
+        Scalc_ = Scalc_active + Scalc_passive
 
-        dS = self.Scalc - Sbus
+        dS = Scalc_ - Sbus
 
         # compose the residuals vector ---------------------------------------------------------------------------------
-        _f = np.r_[
+        f_ = np.r_[
             dS[self.i_k_p].real,
             dS[self.i_k_q].imag,
             loss_vsc,
@@ -1374,7 +1375,23 @@ class PfGeneralizedFormulation(PfFormulationTemplate):
             Qt_cbr - self.cbr_qt_set
         ]
 
-        return _f
+        if update_class_vars:
+            self._Va = Va_
+            self._Vm = Vm_
+            self.Pf_vsc = Pf_vsc_
+            self.Pt_vsc = Pt_vsc_
+            self.Qt_vsc = Qt_vsc_
+            self.Pf_hvdc = Pf_hvdc_
+            self.Pt_hvdc = Pt_hvdc_
+            self.Qf_hvdc = Qf_hvdc_
+            self.Qt_hvdc = Qt_hvdc_
+            self.m = m_
+            self.tau = tau_
+            self.Scalc = Scalc_
+            self.adm = adm_
+            self._f = f_
+
+        return f_
 
     def check_error(self, x: Vec) -> Tuple[float, Vec]:
         """
@@ -1382,7 +1399,7 @@ class PfGeneralizedFormulation(PfFormulationTemplate):
         :param x: Solution vector
         :return: error
         """
-        _res = self.compute_f(x)
+        _res = self.compute_f(x, update_class_vars=False)
         err = compute_fx_error(_res)
 
         # compute the error
@@ -1402,7 +1419,7 @@ class PfGeneralizedFormulation(PfFormulationTemplate):
         self.V = polar_to_rect(self.Vm, self.Va)
 
         # compute f(x)
-        self._f = self.compute_f(x)
+        self._f = self.compute_f(x, update_class_vars=True)
 
         self._error = compute_fx_error(self._f)