GridCalEngine 5.3.16__tar.gz → 5.3.18__tar.gz

{gridcalengine-5.3.16 → gridcalengine-5.3.18}/GridCalEngine/Simulations/ShortCircuitStudies/short_circuit.py

@@ -8,15 +8,17 @@ from scipy.sparse.linalg import spsolve
 from scipy.sparse.linalg import inv
 from scipy.sparse import csc_matrix
 from GridCalEngine.enumerations import FaultType
-from GridCalEngine.basic_structures import CxVec
+from GridCalEngine.basic_structures import CxVec, Vec
 
 
-def short_circuit_3p(bus_idx: int, Ybus: csc_matrix, Vbus: CxVec, Zf: CxVec, baseMVA: float) -> Tuple[CxVec, float]:
+def short_circuit_3p(bus_idx: int, Ybus: csc_matrix, Vbus: CxVec, Vnom: Vec, Zf: CxVec, baseMVA: float) -> Tuple[
+    CxVec, float, float]:
     """
     Executes a 3-phase balanced short circuit study
     :param bus_idx: Index of the bus at which the short circuit is being studied
     :param Ybus: Admittance matrix
     :param Vbus: Voltages of the buses in the steady state
+    :param Vnom: Nominal Voltages of the buses (kV)
     :param Zf: Fault impedance array
     :param baseMVA: 
     :return: Voltages after the short circuit (p.u.), Short circuit power in MVA
@@ -40,9 +42,11 @@ def short_circuit_3p(bus_idx: int, Ybus: csc_matrix, Vbus: CxVec, Zf: CxVec, bas
     V = Vbus + Av
 
     idx_buses = range(n)
+    Ibase = baseMVA / Vnom[idx_buses]
+    ICC = Ibase * Vbus[idx_buses] / Zii
     SCC = baseMVA * Vbus[idx_buses] * Vbus[idx_buses] / Zii
 
-    return V, SCC
+    return V, SCC, ICC
 
 
 def short_circuit_unbalance(bus_idx: int,
@@ -50,9 +54,10 @@ def short_circuit_unbalance(bus_idx: int,
                             Y1: csc_matrix,
                             Y2: csc_matrix,
                             Vbus: CxVec,
+                            Vnom: Vec,
                             Zf: CxVec,
                             fault_type: FaultType,
-                            baseMVA) -> Tuple[CxVec, CxVec, CxVec, CxVec]:
+                            baseMVA) -> Tuple[CxVec, CxVec, CxVec, CxVec, CxVec]:
     """
     Executes the unbalanced short circuits (LG, LL, LLG types)
 
@@ -61,6 +66,7 @@ def short_circuit_unbalance(bus_idx: int,
     :param Y1: Admittance matrix for the positive sequence
     :param Y2: Admittance matrix for the negative sequence
     :param Vbus: pre-fault voltage (positive sequence)
+    :param Vnom: nominal voltage (kV)
     :param Zf: fault impedance
     :param fault_type: type of unbalanced fault
     :param baseMVA: base MVA (100 MVA)
@@ -109,6 +115,9 @@ def short_circuit_unbalance(bus_idx: int,
     V2_fin = - spsolve(Y2, I2_vec)
 
     SCC = np.zeros_like(Vbus)
+    ICC = np.zeros_like(Vbus)
+    Ibase = baseMVA / Vnom[bus_idx]
+    ICC[bus_idx] = Ibase * V1_fin[bus_idx] / Zth1
     SCC[bus_idx] = baseMVA * V1_fin[bus_idx] * V1_fin[bus_idx] / Zth1
 
-    return V0_fin, V1_fin, V2_fin, SCC
+    return V0_fin, V1_fin, V2_fin, SCC, ICC

{gridcalengine-5.3.16 → gridcalengine-5.3.18}/GridCalEngine/Simulations/ShortCircuitStudies/short_circuit_results.py

@@ -40,7 +40,11 @@ class ShortCircuitResults(ResultsTemplate):
                                                               ResultTypes.BusVoltageAngle2,
 
                                                               ResultTypes.BusShortCircuitActivePower,
-                                                              ResultTypes.BusShortCircuitReactivePower],
+                                                              ResultTypes.BusShortCircuitReactivePower,
+
+                                                              ResultTypes.BusShortCircuitActiveCurrent,
+                                                              ResultTypes.BusShortCircuitReactiveCurrent
+                                                              ],
 
                                      ResultTypes.BranchResults: [ResultTypes.BranchActivePowerFrom0,
                                                                  ResultTypes.BranchActivePowerFrom1,
@@ -128,6 +132,7 @@ class ShortCircuitResults(ResultsTemplate):
         self.sc_bus_index = 0
         self.sc_type = FaultType.ph3
         self.SCpower = np.zeros(n, dtype=complex)
+        self.ICurrent = np.zeros(n, dtype=complex)
 
         # Register results
         self.register(name='bus_names', tpe=StrVec)
@@ -180,6 +185,7 @@ class ShortCircuitResults(ResultsTemplate):
         self.register(name='sc_bus_index', tpe=int)
         self.register(name='sc_type', tpe=FaultType)
         self.register(name='SCpower', tpe=CxVec)
+        self.register(name='ICurrent', tpe=CxVec)
 
 
     @property
@@ -191,7 +197,7 @@ class ShortCircuitResults(ResultsTemplate):
         val = 0.0
         return val
 
-    def apply_from_island(self, results: "ShortCircuitResults", b_idx, br_idx):
+    def apply_from_island(self, results: "ShortCircuitResults", b_idx: IntVec, br_idx: IntVec):
         """
         Apply results from another island circuit to the circuit results represented
         here.
@@ -205,6 +211,7 @@ class ShortCircuitResults(ResultsTemplate):
             **elm_idx**: branch original indices
         """
         self.SCpower[b_idx] = results.SCpower
+        self.ICurrent[b_idx] = results.ICurrent
 
         self.Sbus1[b_idx] = results.Sbus1
         self.voltage1[b_idx] = results.voltage1
@@ -278,7 +285,7 @@ class ShortCircuitResults(ResultsTemplate):
         :return:
         """
 
-        columns = [result_type.value]
+        columns = np.array([result_type.value])
         title = result_type.value
 
         if result_type == ResultTypes.BusVoltageModule0:
@@ -337,6 +344,34 @@ class ShortCircuitResults(ResultsTemplate):
                                 ylabel=y_label,
                                 units=y_label)
 
+        elif result_type == ResultTypes.BusShortCircuitActiveCurrent:
+            labels = self.bus_names
+            y = np.real(self.ICurrent)
+            y_label = '(kA)'
+
+            return ResultsTable(data=y,
+                                index=labels,
+                                idx_device_type=DeviceType.BusDevice,
+                                columns=columns,
+                                cols_device_type=DeviceType.NoDevice,
+                                title=title,
+                                ylabel=y_label,
+                                units=y_label)
+
+        elif result_type == ResultTypes.BusShortCircuitReactiveCurrent:
+            labels = self.bus_names
+            y = np.imag(self.ICurrent)
+            y_label = '(kAr)'
+
+            return ResultsTable(data=y,
+                                index=labels,
+                                idx_device_type=DeviceType.BusDevice,
+                                columns=columns,
+                                cols_device_type=DeviceType.NoDevice,
+                                title=title,
+                                ylabel=y_label,
+                                units=y_label)
+
         elif result_type == ResultTypes.BranchActivePowerFrom0:
             labels = self.branch_names
             y = self.Sf0.real

{gridcalengine-5.3.16 → gridcalengine-5.3.18}/GridCalEngine/Simulations/ShortCircuitStudies/short_circuit_worker.py

@@ -71,11 +71,12 @@ def short_circuit_ph3(nc: NumericalCircuit, Vpf: CxVec, Zf: CxVec, bus_index: in
     Ybus_gen_batt = adm.Ybus + sp.diags(Y_gen) + sp.diags(Y_batt)
 
     # Compute the short circuit
-    V, SCpower = short_circuit_3p(bus_idx=bus_index,
-                                  Ybus=Ybus_gen_batt,
-                                  Vbus=Vpf,
-                                  Zf=Zf,
-                                  baseMVA=nc.Sbase)
+    V, SCpower, ICurrent = short_circuit_3p(bus_idx=bus_index,
+                                            Ybus=Ybus_gen_batt,
+                                            Vbus=Vpf,
+                                            Vnom=nc.bus_data.Vnom,
+                                            Zf=Zf,
+                                            baseMVA=nc.Sbase)
 
     (Sfb, Stb, If, It, Vbranch,
      loading, losses) = short_circuit_post_process(calculation_inputs=nc,
@@ -95,6 +96,7 @@ def short_circuit_ph3(nc: NumericalCircuit, Vpf: CxVec, Zf: CxVec, bus_index: in
                                   area_names=None)
 
     results.SCpower = SCpower
+    results.ICurrent = ICurrent
     results.Sbus1 = nc.get_power_injections_pu() * nc.Sbase  # MVA
     results.voltage1 = V
     results.Sf1 = Sfb  # in MVA already
@@ -117,6 +119,7 @@ def short_circuit_unbalanced(nc: NumericalCircuit,
     Run an unbalanced short circuit simulation for a single island
     :param nc:
     :param Vpf: Power flow voltage vector applicable to the island
+    :param Vnom: Buses nominal voltages (kV)
     :param Zf: Short circuit impedance vector applicable to the island
     :param bus_index: Index of the failed bus
     :param fault_type: FaultType
@@ -243,14 +246,15 @@ def short_circuit_unbalanced(nc: NumericalCircuit,
     Vpf[pqpv] = polar_to_rect(np.abs(Vpf[pqpv]), np.angle(Vpf[pqpv]) + ph_add.T)
 
     # solve the fault
-    V0, V1, V2, SCC = short_circuit_unbalance(bus_idx=bus_index,
-                                              Y0=adm0.Ybus,
-                                              Y1=adm1.Ybus,
-                                              Y2=adm2.Ybus,
-                                              Vbus=Vpf,
-                                              Zf=Zf,
-                                              fault_type=fault_type,
-                                              baseMVA=nc.Sbase)
+    V0, V1, V2, SCC, ICC = short_circuit_unbalance(bus_idx=bus_index,
+                                                   Y0=adm0.Ybus,
+                                                   Y1=adm1.Ybus,
+                                                   Y2=adm2.Ybus,
+                                                   Vnom=nc.bus_data.Vnom,
+                                                   Vbus=Vpf,
+                                                   Zf=Zf,
+                                                   fault_type=fault_type,
+                                                   baseMVA=nc.Sbase)
 
     # process results in the sequences
     (Sfb0, Stb0, If0, It0, Vbranch0,
@@ -285,6 +289,7 @@ def short_circuit_unbalanced(nc: NumericalCircuit,
                                   area_names=None)
 
     results.SCpower = SCC
+    results.ICurrent = ICC
 
     results.voltage0 = V0
     results.Sf0 = Sfb0  # in MVA already

{gridcalengine-5.3.16 → gridcalengine-5.3.18}/GridCalEngine/Topology/topology.py

@@ -47,7 +47,7 @@ def find_islands_numba(node_number: int, indptr: IntVec, indices: IntVec, active
             # DFS: store in the island all the reachable vertices from current vertex "node"
             #
             # declare a stack with the initial node to visit (node)
-            stack = list()  # type: List[int]
+            stack: List[int] = list()  # type:
             stack.append(node)
 
             while len(stack) > 0:
@@ -474,10 +474,28 @@ def dev_per_bus(nbus: int, bus_indices: IntVec) -> IntVec:
     Summation of magnitudes per bus (bool)
     :param nbus: number of buses
     :param bus_indices: elements' bus indices
-    :param magnitude: elements' magnitude to add per bus
     :return: array of size nbus
     """
     res = np.zeros(nbus, dtype=np.int64)
     for i in range(len(bus_indices)):
         res[bus_indices[i]] += 1
-    return res
+    return res
+
+
+def accept_line_connection(V1: float, V2: float, branch_connection_voltage_tolerance=0.1) -> float:
+    """
+    This function checks if a line can be connected between 2 voltages
+    :param V1: Voltage 1
+    :param V2: Voltage 2
+    :param branch_connection_voltage_tolerance:
+    :return: Can be connected?
+    """
+    if V2 > 0:
+        per = V1 / V2
+
+        if per < (1.0 - branch_connection_voltage_tolerance):
+            return False
+        else:
+            return True
+    else:
+        return V1 == V2

{gridcalengine-5.3.16 → gridcalengine-5.3.18}/GridCalEngine/__version__.py

@@ -6,7 +6,7 @@ import datetime
 _current_year_ = datetime.datetime.now().year
 
 # do not forget to keep a three-number version!!!
-__GridCalEngine_VERSION__ = "5.3.16"
+__GridCalEngine_VERSION__ = "5.3.18"
 
 url = 'https://github.com/SanPen/GridCal'
 

{gridcalengine-5.3.16 → gridcalengine-5.3.18}/GridCalEngine/enumerations.py

@@ -1360,6 +1360,9 @@ class ResultTypes(Enum):
     BusShortCircuitActivePower = 'Short circuit active power'
     BusShortCircuitReactivePower = 'Short circuit reactive power'
 
+    BusShortCircuitActiveCurrent = 'Short circuit active current'
+    BusShortCircuitReactiveCurrent = 'Short circuit reactive current'
+
     # PTDF
     PTDF = 'PTDF'
     PTDFBusVoltageSensitivity = 'Bus voltage sensitivity'

{gridcalengine-5.3.16 → gridcalengine-5.3.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: GridCalEngine
-Version: 5.3.16
+Version: 5.3.18
 Summary: GridCal is a Power Systems simulation program intended for professional use and research
 Home-page: https://github.com/SanPen/GridCal
 Author: Santiago Peñate Vera et. Al.