VeraGridEngine 5.5.16__tar.gz → 5.5.17__tar.gz

{veragridengine-5.5.16 → veragridengine-5.5.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: VeraGridEngine
-Version: 5.5.16
+Version: 5.5.17
 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.5.16 → veragridengine-5.5.17}/VeraGridEngine/Simulations/ContingencyAnalysis/Methods/helm_contingencies.py

@@ -33,6 +33,8 @@ def calc_V_outage(nc: NumericalCircuit,
                   pv: IntVec,
                   vd: IntVec,
                   pqpv: IntVec,
+                  pqpv_original: IntVec,
+                  pq_original: IntVec,
                   contingency_br_indices: IntVec):
     """
     Calculate the voltage due to outages in a non-linear manner with HELM.
@@ -57,6 +59,8 @@ def calc_V_outage(nc: NumericalCircuit,
     :param pv: set of PV buses
     :param vd: set of slack buses
     :param pqpv: set of PQ + PV buses
+    :param pqpv_original: set of PQ + PV buses in the original order
+    :param pq_original: set of PQ buses in the original order, considering slack
     :param contingency_br_indices: array of branch indices of the contingency
     :return: V, Sf, loading, norm_f
     """
@@ -104,8 +108,10 @@ def calc_V_outage(nc: NumericalCircuit,
                                            npqpv=len(pqpv),
                                            nbus=nc.nbus,
                                            sl=vd,
+                                           pqpv_original=pqpv_original,
+                                           pq_original=pq_original,
                                            tolerance=1e-6,
-                                           max_coeff=10)
+                                           max_coeff=30)
 
     # compute flows
     Sf = V[nc.passive_branch_data.F] * np.conj(Yf @ V) * nc.Sbase
@@ -223,7 +229,9 @@ class HelmVariations:
                         pv=pre.pv,
                         vd=pre.sl,
                         pqpv=pre.pqpv,
-                        contingency_br_indices=contingency_br_indices_is
+                        pqpv_original=pre.pqpv_original,
+                        pq_original=pre.pq_original,
+                        contingency_br_indices=contingency_br_indices_is,
                     )
 
                     # assign objects to the full matrix

{veragridengine-5.5.16 → veragridengine-5.5.17}/VeraGridEngine/Simulations/ContingencyAnalysis/Methods/helm_contingency_analysis.py

@@ -100,6 +100,7 @@ def helm_contingency_analysis(grid: MultiCircuit,
             contingency_br_indices=np.array(contingency_br_indices)
         )
 
+        results.voltage[ic, :] = V
         results.Sf[ic, :] = Sf
         results.Sbus[ic, :] = Sbus
         results.loading[ic, :] = loading

{veragridengine-5.5.16 → veragridengine-5.5.17}/VeraGridEngine/Simulations/PowerFlow/NumericalMethods/helm_power_flow.py

@@ -454,7 +454,7 @@ class HelmPreparation:
 
     def __init__(self, sys_mat_factorization, Uini, Xini, Yslack, Vslack,
                  vec_P, vec_Q, Ysh, vec_W, pq, pv, pqpv, sl,
-                 npqpv, nbus):
+                 npqpv, nbus, pqpv_original, pq_original):
         """
 
         :param sys_mat_factorization:
@@ -472,6 +472,7 @@ class HelmPreparation:
         :param sl:
         :param npqpv:
         :param nbus:
+        :param pqpv_original:
         """
         self.sys_mat_factorization = sys_mat_factorization
         self.Uini = Uini
@@ -488,6 +489,8 @@ class HelmPreparation:
         self.pqpv = pqpv
         self.npqpv = npqpv
         self.nbus = nbus
+        self.pqpv_original = pqpv_original
+        self.pq_original = pq_original
 
 
 def helm_preparation_dY(Yseries, V0, S0, Ysh0, pq, pv, sl, pqpv, verbose: int = 0,
@@ -538,6 +541,9 @@ def helm_preparation_dY(Yseries, V0, S0, Ysh0, pq, pv, sl, pqpv, verbose: int =
             compt += 1
         nsl_counted[i] = compt
 
+    pqpv_original = np.sort(np.r_[pq, pv])
+    pq_original = np.sort(np.r_[pq])
+
     pq_ = pq - nsl_counted[pq]
     pv_ = pv - nsl_counted[pv]
     pqpv_ = np.sort(np.r_[pq_, pv_])
@@ -570,12 +576,13 @@ def helm_preparation_dY(Yseries, V0, S0, Ysh0, pq, pv, sl, pqpv, verbose: int =
     mat_factorized = factorized(MAT)
 
     return HelmPreparation(mat_factorized, Uini, Xini, Yslack, Vslack, vec_P, vec_Q, Ysh, vec_W,
-                           pq_, pv_, pqpv_, sl, npqpv, nbus)
+                           pq_, pv_, pqpv_, sl, npqpv, nbus, pqpv_original, pq_original)
 
 
 def helm_coefficients_dY(dY, sys_mat_factorization, Uini, Xini,
                          Yslack, Ysh, Ybus, vec_P, vec_Q, S0,
-                         vec_W, V0, Vslack, pq, pv, pqpv, npqpv, nbus, sl,
+                         vec_W, V0, Vslack, pq, pv, pqpv, npqpv, nbus, sl, 
+                         pqpv_original, pq_original, 
                          tolerance=1e-6, max_coeff=10):
     """
     Holomorphic Embedding LoadFlow Method as formulated by Josep Fanals Batllori in 2020
@@ -605,12 +612,14 @@ def helm_coefficients_dY(dY, sys_mat_factorization, Uini, Xini,
     :param pqpv: sorted list of pq and pv nodes
     :param pq:list of pq nodes
     :param sl: list of slack nodes
+    :param pqpv_original: sorted list of pq and pv nodes in the original order, considering slack
+    :param pq_original: list of pq nodes in the original order, considering slack
     :param tolerance: target error (or tolerance)
     :param max_coeff: maximum number of coefficients
     :return: U, V, iter_, norm_f
     """
 
-    AYred = dY[np.ix_(pqpv, pqpv)]  # difference admittance matrix without slack buses
+    AYred = dY[np.ix_(pqpv_original, pqpv_original)]  # difference admittance matrix without slack buses
 
     # --------------------------- PREPARING IMPLEMENTATION -------------------------------------------------------------
     U = np.zeros((max_coeff + 1, npqpv), dtype=complex)  # voltages
@@ -630,8 +639,8 @@ def helm_coefficients_dY(dY, sys_mat_factorization, Uini, Xini,
 
     Ysl_sum = Yslack.sum(axis=1).A1
 
-    dval[pq] = I_inj_slack[pq] - Ysl_sum[pq] + (vec_P[pq] - vec_Q[pq] * 1j) * X[0, pq] - U[0, pq] * Ysh[pq] - AIred[pq]
-    dval[pv] = I_inj_slack[pv] - Ysl_sum[pv] + (vec_P[pv]) * X[0, pv] - U[0, pv] * Ysh[pv] - AIred[pv]
+    dval[pq] = I_inj_slack[pq] - Ysl_sum[pq] + (vec_P[pq] - vec_Q[pq] * 1j) * X[0, pq] - U[0, pq] * Ysh[pq] + 1.0 * AIred[pq]
+    dval[pv] = I_inj_slack[pv] - Ysl_sum[pv] + (vec_P[pv]) * X[0, pv] - U[0, pv] * Ysh[pv] + 1.0 * AIred[pv]
 
     # compose the right-hand side vector
     RHS = np.r_[dval.real, dval.imag, vec_W[pv] - (U[0, pv] * U[0, pv]).real]  # vec_W[pv_] - 1.0
@@ -647,17 +656,23 @@ def helm_coefficients_dY(dY, sys_mat_factorization, Uini, Xini,
     iter_ = 1
     c = 2
     converged = False
-    V = np.empty(nbus, dtype=complex)
+    # V = np.empty(nbus, dtype=complex)
+    # V[sl] = V0[sl]
+    # V[pqpv] = U[:c, :].sum(axis=0)
+
+    # Need the rebuild the voltage vector, as the passed pqpv indices are already reduced    
+    V = np.zeros(nbus, dtype=complex)
     V[sl] = V0[sl]
-    V[pqpv] = U[:c, :].sum(axis=0)
+    V[pqpv_original] = U[:c, :].sum(axis=0)
+
     norm_f = 0.0
 
     while c <= max_coeff and not converged:  # c defines the current depth
 
-        AIred = AYred * U[c - 1, :]
+        AIred = AYred @ U[c - 1, :]
 
-        dval[pq] = (vec_P[pq] - vec_Q[pq] * 1j) * X[c - 1, pq] - U[c - 1, pq] * Ysh[pq] - AIred[pq]
-        dval[pv] = -1j * conv2(X, Q, c, pv) - U[c - 1, pv] * Ysh[pv] + X[c - 1, pv] * vec_P[pv] - AIred[pv]
+        dval[pq] = (vec_P[pq] - vec_Q[pq] * 1j) * X[c - 1, pq] - U[c - 1, pq] * Ysh[pq] + 1.0 * AIred[pq]
+        dval[pv] = -1j * conv2(X, Q, c, pv) - U[c - 1, pv] * Ysh[pv] + X[c - 1, pv] * vec_P[pv] + 1.0 * AIred[pv]
 
         RHS = np.r_[dval.real, dval.imag, -conv3(U, U, c, pv).real]
 
@@ -670,11 +685,11 @@ def helm_coefficients_dY(dY, sys_mat_factorization, Uini, Xini,
         X[c, :] = -conv1(U, X, c) / np.conj(U[0, :])
 
         # compute power mismatch
-        V[pqpv] += U[c, :]
+        V[pqpv_original] += U[c, :]
 
         if V.real.max() < 10:
-            Scalc = cf.compute_power(Ybus, V)
-            norm_f = cf.compute_fx_error(cf.compute_fx(Scalc, S0, pqpv, pq))
+            Scalc = cf.compute_power(Ybus - dY, V)
+            norm_f = cf.compute_fx_error(cf.compute_fx(Scalc, S0, pqpv_original, pq_original))
             converged = (norm_f <= tolerance) and (c % 2)  # we want an odd amount of coefficients
         else:
             # completely erroneous

{veragridengine-5.5.16 → veragridengine-5.5.17}/VeraGridEngine/Simulations/Rms/initialization.py

@@ -2,18 +2,15 @@
 # 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
-import pdb
+
 from typing import Tuple, Any, Sequence, Callable, Dict
 import math
 import numba as nb
 import numpy as np
-from pygments.lexers.textfmts import TodotxtLexer
-from scipy.optimize import newton_krylov
 
 from VeraGridEngine.Devices.Parents.physical_device import PhysicalDevice
-from VeraGridEngine.Utils.Symbolic import BlockSolver
-from VeraGridEngine.Utils.Symbolic.symbolic import _emit, _emit_one
-from VeraGridEngine.Utils.Symbolic.block import Block, Expr, Var
+from VeraGridEngine.Utils.Symbolic.symbolic import _emit_one
+from VeraGridEngine.Utils.Symbolic.block import Block, Expr
 from VeraGridEngine.Devices.multi_circuit import MultiCircuit
 from VeraGridEngine.Simulations.PowerFlow.power_flow_results import PowerFlowResults
 from VeraGridEngine.enumerations import DynamicVarType
@@ -27,7 +24,6 @@ def _compile_equation(eqs: Sequence[Expr],
     Compile the array of expressions to a function that returns an array of values for those expressions
     :param eqs: Iterable of expressions (Expr)
     :param uid2sym_vars: dictionary relating the uid of a var with its array name (i.e. var[0])
-    :param uid2sym_params:
     :param add_doc_string: add the docstring?
     :return: Function pointer that returns an array
     """
@@ -47,8 +43,9 @@ def _compile_equation(eqs: Sequence[Expr],
 
 
 def compose_system_block(grid: MultiCircuit,
-                          power_flow_results: PowerFlowResults, vars2device:Dict[int, PhysicalDevice], vars_glob_name2uid: Dict[str, int]) -> Tuple[Block, Dict[Tuple[int, str], float]]:
-
+                         power_flow_results: PowerFlowResults,
+                         vars2device: Dict[int, PhysicalDevice],
+                         vars_glob_name2uid: Dict[str, int]) -> Tuple[Block, Dict[Tuple[int, str], float]]:
     """
     Compose all RMS models
     :param grid:
@@ -151,9 +148,12 @@ def compose_system_block(grid: MultiCircuit,
         bus_rms_mdl = elm.bus.rms_model.model
         mdl = elm.rms_model.model
 
-
-        init_guess[(mdl.external_mapping[DynamicVarType.P].uid, mdl.external_mapping[DynamicVarType.P].name)] = init_guess[(bus_rms_mdl.external_mapping[DynamicVarType.P].uid, bus_rms_mdl.external_mapping[DynamicVarType.P].name)]
-        init_guess[(mdl.external_mapping[DynamicVarType.Q].uid, mdl.external_mapping[DynamicVarType.Q].name)] = init_guess[(bus_rms_mdl.external_mapping[DynamicVarType.Q].uid, bus_rms_mdl.external_mapping[DynamicVarType.Q].name)]
+        init_guess[(mdl.external_mapping[DynamicVarType.P].uid, mdl.external_mapping[DynamicVarType.P].name)] = \
+        init_guess[
+            (bus_rms_mdl.external_mapping[DynamicVarType.P].uid, bus_rms_mdl.external_mapping[DynamicVarType.P].name)]
+        init_guess[(mdl.external_mapping[DynamicVarType.Q].uid, mdl.external_mapping[DynamicVarType.Q].name)] = \
+        init_guess[
+            (bus_rms_mdl.external_mapping[DynamicVarType.Q].uid, bus_rms_mdl.external_mapping[DynamicVarType.Q].name)]
 
         mdl_vars = mdl.state_vars + mdl.algebraic_vars
 
@@ -200,10 +200,10 @@ def compose_system_block(grid: MultiCircuit,
 
     # del buses P, Q
     for i, elm in enumerate(grid.buses):
-            mdl = elm.rms_model.model
-            del init_guess[(mdl.external_mapping[DynamicVarType.P].uid,
+        mdl = elm.rms_model.model
+        del init_guess[(mdl.external_mapping[DynamicVarType.P].uid,
                         mdl.external_mapping[DynamicVarType.P].name)]
-            del init_guess[(mdl.external_mapping[DynamicVarType.Q].uid,
+        del init_guess[(mdl.external_mapping[DynamicVarType.Q].uid,
                         mdl.external_mapping[DynamicVarType.Q].name)]
 
     return sys_block, init_guess
@@ -232,7 +232,7 @@ def initialize_rms(grid: MultiCircuit, power_flow_results, logger: Logger = Logg
 
     # instantiate vars2device  and vars_glob_name2uid dicts
 
-    vars2device:Dict[int, PhysicalDevice] = dict()
+    vars2device: Dict[int, PhysicalDevice] = dict()
     vars_glob_name2uid: Dict[str, int] = dict()
     # find events
     rms_events = grid.rms_events
@@ -248,8 +248,6 @@ def initialize_rms(grid: MultiCircuit, power_flow_results, logger: Logger = Logg
     P_used = np.zeros(n, dtype=int)
     Q_used = np.zeros(n, dtype=int)
 
-
-
     # initialize buses
     for i, elm in enumerate(grid.buses):
         elm.initialize_rms()

{veragridengine-5.5.16 → veragridengine-5.5.17}/VeraGridEngine/Simulations/Rms/numerical/integration_methods.py

@@ -2,7 +2,6 @@
 # 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
-import pdb
 import sys
 import numpy as np
 from scipy.sparse import bmat, identity, csc_matrix

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