GridCalEngine 5.3.4__tar.gz → 5.3.6__tar.gz

{gridcalengine-5.3.4 → gridcalengine-5.3.6}/GridCalEngine/Compilers/circuit_to_data.py

@@ -639,6 +639,7 @@ def fill_generator_parent(
 
     data.controllable[k] = elm.is_controlled
     data.installed_p[k] = elm.Snom
+    bus_data.installed_power[i] += elm.Snom
 
     # r0, r1, r2, x0, x1, x2
     data.r0[k] = elm.R0

{gridcalengine-5.3.4 → gridcalengine-5.3.6}/GridCalEngine/Compilers/circuit_to_optimods.py

@@ -41,8 +41,13 @@ def solve_acopf(case: Dict) -> Dict:
     :param case:
     :return:
     """
-    res = opf.solve_opf(case, opftype="AC")
-    return res
+    if GUROBI_OPTIMODS_AVAILABLE:
+        res = opf.solve_opf(case, opftype="AC")
+        return res
+    else:
+        raise ImportError("No gurobi optimization available")
+
+
 
 
 if __name__ == '__main__':
@@ -50,6 +55,7 @@ if __name__ == '__main__':
     fname = r'/home/santi/matpower8.0b1/data/case9_gurobi_test.m'
 
     # Gurobi
+    # case_ = gce.to_matpower(grid)
     case_ = gce.get_matpower_case_data(fname, force_linear_cost=True)
     result_optimods = solve_acopf(case_)
 

{gridcalengine-5.3.4 → gridcalengine-5.3.6}/GridCalEngine/DataStructures/generator_data.py

@@ -39,7 +39,7 @@ class GeneratorData:
         self.snom: Vec = np.zeros(nelm, dtype=float)
         self.q_share: Vec = np.zeros(nelm, dtype=float)
 
-        # reliabilty
+        # reliability
         self.mttf: Vec = np.zeros(nelm, dtype=float)
         self.mttr: Vec = np.zeros(nelm, dtype=float)
 

{gridcalengine-5.3.4 → gridcalengine-5.3.6}/GridCalEngine/DataStructures/numerical_circuit.py

@@ -474,6 +474,14 @@ class NumericalCircuit:
         """
         return self.__topology_performed
 
+
+    def get_reduction_bus_mapping(self) -> IntVec:
+        """
+        Get array is used to keep track of the bus topological reduction
+        :return: IntVec
+        """
+        return self.__bus_map_arr
+
     def get_power_injections(self) -> CxVec:
         """
         Compute the power
@@ -512,7 +520,7 @@ class NumericalCircuit:
         """
         return self.load_data.get_admittance_injections_per_bus() / self.Sbase
 
-    def get_Yshunt_bus(self) -> CxVec:
+    def get_Yshunt_bus_pu(self) -> CxVec:
         """
 
         :return:
@@ -533,8 +541,8 @@ class NumericalCircuit:
         self.nbatt = len(self.battery_data)
         self.nshunt = len(self.shunt_data)
 
-        self.bus_data.installed_power = self.generator_data.get_installed_power_per_bus()
-        self.bus_data.installed_power += self.battery_data.get_installed_power_per_bus()
+        # self.bus_data.installed_power = self.generator_data.get_installed_power_per_bus()
+        # self.bus_data.installed_power += self.battery_data.get_installed_power_per_bus()
 
         if self.active_branch_data.any_pf_control is False:
             if self.vsc_data.nelm > 0:
@@ -751,14 +759,13 @@ class NumericalCircuit:
             X=self.passive_branch_data.X,
             G=self.passive_branch_data.G,
             B=self.passive_branch_data.B,
-            k=self.passive_branch_data.k,
             tap_module=self.active_branch_data.tap_module,
             vtap_f=self.passive_branch_data.virtual_tap_f,
             vtap_t=self.passive_branch_data.virtual_tap_t,
             tap_angle=self.active_branch_data.tap_angle,
             Cf=self.passive_branch_data.Cf.tocsc(),
             Ct=self.passive_branch_data.Ct.tocsc(),
-            Yshunt_bus=self.get_Yshunt_bus(),
+            Yshunt_bus=self.get_Yshunt_bus_pu(),
             conn=self.passive_branch_data.conn,
             seq=1
         )
@@ -773,21 +780,14 @@ class NumericalCircuit:
             X=self.passive_branch_data.X,
             G=self.passive_branch_data.G,
             B=self.passive_branch_data.B,
-            k=self.passive_branch_data.k,
             active=self.passive_branch_data.active.astype(int),
             tap_module=self.active_branch_data.tap_module,
             vtap_f=self.passive_branch_data.virtual_tap_f,
             vtap_t=self.passive_branch_data.virtual_tap_t,
             tap_angle=self.active_branch_data.tap_angle,
-            Beq=np.zeros(self.nbr, dtype=float),
             Cf=self.passive_branch_data.Cf.tocsc(),
             Ct=self.passive_branch_data.Ct.tocsc(),
-            G0sw=np.zeros(self.nbr, dtype=float),
-            If=np.zeros(len(self.passive_branch_data), dtype=complex),
-            a=np.zeros(self.nbr, dtype=float),
-            b=np.zeros(self.nbr, dtype=float),
-            c=np.zeros(self.nbr, dtype=float),
-            Yshunt_bus=self.get_Yshunt_bus(),
+            Yshunt_bus=self.get_Yshunt_bus_pu(),
         )
 
     def get_fast_decoupled_amittances(self) -> ycalc.FastDecoupledAdmittanceMatrices:
@@ -1007,7 +1007,7 @@ class NumericalCircuit:
 
         elif structure_type == 'Yshunt':
             df = pd.DataFrame(
-                data=self.get_Yshunt_bus(),
+                data=self.get_Yshunt_bus_pu(),
                 columns=['Shunt admittance (p.u.)'],
                 index=self.bus_data.names,
             )
@@ -1407,10 +1407,12 @@ class NumericalCircuit:
                                               elm_active=self.passive_branch_data.active,
                                               F=self.passive_branch_data.F,
                                               T=self.passive_branch_data.T)
+
         hvdc_idx = tp.get_island_branch_indices(bus_map=bus_map,
                                                 elm_active=self.hvdc_data.active,
                                                 F=self.hvdc_data.F,
                                                 T=self.hvdc_data.T)
+
         vsc_idx = tp.get_island_branch_indices(bus_map=bus_map,
                                                elm_active=self.vsc_data.active,
                                                F=self.vsc_data.F,
@@ -1419,12 +1421,15 @@ class NumericalCircuit:
         load_idx = tp.get_island_monopole_indices(bus_map=bus_map,
                                                   elm_active=self.load_data.active,
                                                   elm_bus=self.load_data.bus_idx)
+
         gen_idx = tp.get_island_monopole_indices(bus_map=bus_map,
                                                  elm_active=self.generator_data.active,
                                                  elm_bus=self.generator_data.bus_idx)
+
         batt_idx = tp.get_island_monopole_indices(bus_map=bus_map,
                                                   elm_active=self.battery_data.active,
                                                   elm_bus=self.battery_data.bus_idx)
+
         shunt_idx = tp.get_island_monopole_indices(bus_map=bus_map,
                                                    elm_active=self.shunt_data.active,
                                                    elm_bus=self.shunt_data.bus_idx)

{gridcalengine-5.3.4 → gridcalengine-5.3.6}/GridCalEngine/Devices/Aggregation/area.py

@@ -26,8 +26,8 @@ class GenericAreaGroup(EditableDevice):
                                 idtag=idtag,
                                 device_type=device_type)
 
-        self.latitude = latitude
-        self.longitude = longitude
+        self.latitude = float(latitude)
+        self.longitude = float(longitude)
 
         self.color = color if color is not None else self.rnd_color()
 

{gridcalengine-5.3.4 → gridcalengine-5.3.6}/GridCalEngine/Devices/Branches/line.py

@@ -12,7 +12,7 @@ from GridCalEngine.enumerations import BuildStatus, SubObjectType, DeviceType
 from GridCalEngine.Devices.Branches.underground_line_type import UndergroundLineType
 from GridCalEngine.Devices.Branches.overhead_line_type import OverheadLineType
 from GridCalEngine.Devices.Parents.branch_parent import BranchParent
-from GridCalEngine.Devices.Branches.sequence_line_type import SequenceLineType
+from GridCalEngine.Devices.Branches.sequence_line_type import SequenceLineType, get_line_impedances_with_c
 from GridCalEngine.Devices.Branches.transformer import Transformer2W
 from GridCalEngine.Devices.profile import Profile
 from GridCalEngine.Devices.Associations.association import Associations
@@ -382,19 +382,25 @@ class Line(BranchParent):
         """
         return np.sqrt(self.R * self.R + self.X * self.X)
 
-    def apply_template(self, obj: Union[OverheadLineType, UndergroundLineType, SequenceLineType], Sbase: float,
+    def apply_template(self, obj: Union[OverheadLineType, UndergroundLineType, SequenceLineType],
+                       Sbase: float, freq: float,
                        logger=Logger()):
         """
         Apply a line template to this object
         :param obj: OverheadLineType, UndergroundLineType, SequenceLineType
         :param Sbase: Nominal power in MVA
+        :param freq: Frequency in Hz
         :param logger: Logger
         """
 
         if type(obj) in [OverheadLineType, UndergroundLineType, SequenceLineType]:
 
-            self.R, self.X, self.B, self.R0, self.X0, self.B0, self.rate = obj.get_values(Sbase=Sbase,
-                                                                                          length=self.length)
+            (self.R, self.X, self.B,
+             self.R0, self.X0, self.B0,
+             self.rate) = obj.get_values(Sbase=Sbase,
+                                         freq=freq,
+                                         length=self.length,
+                                         line_Vnom=self.get_max_bus_nominal_voltage())
 
             if self.template is not None:
                 if obj != self.template:
@@ -499,23 +505,16 @@ class Line(BranchParent):
         :param apply_to_profile: modify the profile is checked
         :return self pointer
         """
-        r_ohm_total = r_ohm * length
-        x_ohm_total = x_ohm * length
-        # impedance = 1 / (2 * pi * f * c),
-        # susceptance = (2 * pi * f * c)
-        b_siemens_total = (2 * np.pi * freq * c_nf * 1e-9) * length
-
-        Vf = self.get_max_bus_nominal_voltage()
-
-        Zbase = (Vf * Vf) / Sbase
-        Ybase = 1.0 / Zbase
-
-        self.R = np.round(r_ohm_total / Zbase, 6)
-        self.X = np.round(x_ohm_total / Zbase, 6)
-        self.B = np.round(b_siemens_total / Ybase, 6)
+        self.R, self.X, self.B, new_rate = get_line_impedances_with_c(r_ohm=r_ohm,
+                                                                      x_ohm=x_ohm,
+                                                                      c_nf=c_nf,
+                                                                      length=length,
+                                                                      Imax=Imax,
+                                                                      freq=freq,
+                                                                      Sbase=Sbase,
+                                                                      Vnom=self.get_max_bus_nominal_voltage())
 
         old_rate = float(self.rate)
-        new_rate = np.round(Imax * Vf * 1.73205080757, 6)  # nominal power in MVA = kA * kV * sqrt(3)
 
         self.rate = new_rate
         self._length = length

{gridcalengine-5.3.4 → gridcalengine-5.3.6}/GridCalEngine/Devices/Branches/overhead_line_type.py

@@ -296,28 +296,43 @@ class OverheadLineType(EditableDevice):
             if self.wires_in_tower[i].wire.name == wire.name:
                 return True
 
-    def get_values(self, Sbase, length):
+    def get_values(self, Sbase, length, round_vals: bool = False):
+
         """
 
-        :param Sbase:
-        :param length:
-        :return:
+        :param Sbase: Base power
+        :param length: Length of the line
+        :param round_vals: Boolean to round parameter values
+        :return: Line parameters and rate
         """
+
         Vn = self.Vnom
         Zbase = (Vn * Vn) / Sbase
         Ybase = 1 / Zbase
 
         z1 = self.z_series() * length / Zbase
         y1 = self.y_shunt() * length * -1e6 / Ybase
-        R1 = np.round(z1.real, 6)
-        X1 = np.round(z1.imag, 6)
-        B1 = np.round(y1.imag, 6)
 
         z0 = self.z0_series() * length / Zbase
         y0 = self.y0_shunt() * length * -1e6 / Ybase
-        R0 = np.round(z0.real, 6)
-        X0 = np.round(z0.imag, 6)
-        B0 = np.round(y0.imag, 6)
+
+        if round_vals:
+            R1 = np.round(z1.real, 6)
+            X1 = np.round(z1.imag, 6)
+            B1 = np.round(y1.imag, 6)
+
+            R0 = np.round(z0.real, 6)
+            X0 = np.round(z0.imag, 6)
+            B0 = np.round(y0.imag, 6)
+
+        else:
+            R1 = z1.real
+            X1 = z1.imag
+            B1 = y1.imag
+
+            R0 = z0.real
+            X0 = z0.imag
+            B0 = y0.imag
 
         z2 = self.z2_series() * length / Zbase
         y2 = self.y2_shunt() * length * -1e6 / Ybase

gridcalengine-5.3.6/GridCalEngine/Devices/Branches/sequence_line_type.py

@@ -0,0 +1,156 @@
+# 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 typing import Tuple
+import numpy as np
+from GridCalEngine.Devices.Parents.editable_device import EditableDevice, DeviceType
+
+
+def get_line_impedances_with_c(r_ohm: float, x_ohm: float, c_nf: float,
+                               length: float, Imax: float,
+                               freq: float, Sbase: float, Vnom: float) -> Tuple[float, float, float, float]:
+    """
+    Fill R, X, B from not-in-per-unit parameters
+    :param r_ohm: Resistance per km in OHM/km
+    :param x_ohm: Reactance per km in OHM/km
+    :param c_nf: Capacitance per km in nF/km
+    :param length: length in kn
+    :param Imax: Maximum current in kA
+    :param freq: System frequency in Hz
+    :param Sbase: Base power in MVA (take always 100 MVA)
+    :param Vnom: nominal voltage (kV)
+    :return R, X, B, rate
+    """
+    r_ohm_total = r_ohm * length
+    x_ohm_total = x_ohm * length
+    b_siemens_total = (2 * np.pi * freq * c_nf * 1e-9) * length
+
+    Zbase = (Vnom * Vnom) / Sbase
+    Ybase = 1.0 / Zbase
+
+    R = np.round(r_ohm_total / Zbase, 6)
+    X = np.round(x_ohm_total / Zbase, 6)
+    B = np.round(b_siemens_total / Ybase, 6)
+
+    rate = np.round(Imax * Vnom * 1.73205080757, 6)  # nominal power in MVA = kA * kV * sqrt(3)
+
+    return R, X, B, rate
+
+
+def get_line_impedances_with_b(r_ohm: float, x_ohm: float, b_us: float, length: float,
+                               Imax: float, Sbase: float, Vnom: float) -> Tuple[float, float, float, float]:
+    """
+    Fill R, X, B from not-in-per-unit parameters
+    :param r_ohm: Resistance per km in OHM/km
+    :param x_ohm: Reactance per km in OHM/km
+    :param b_us: Susceptance per km in uS/km
+    :param length: length in kn
+    :param Imax: Maximum current in kA
+    :param Sbase: Base power in MVA (take always 100 MVA)
+    :param Vnom: nominal voltage (kV)
+    :return R, X, B, rate
+    """
+    r_ohm_total = r_ohm * length
+    x_ohm_total = x_ohm * length
+    b_siemens_total = (b_us * 1e-6) * length
+
+    Zbase = (Vnom * Vnom) / Sbase
+    Ybase = 1.0 / Zbase
+
+    R = np.round(r_ohm_total / Zbase, 6)
+    X = np.round(x_ohm_total / Zbase, 6)
+    B = np.round(b_siemens_total / Ybase, 6)
+
+    rate = np.round(Imax * Vnom * 1.73205080757, 6)  # nominal power in MVA = kA * kV * sqrt(3)
+
+    return R, X, B, rate
+
+
+class SequenceLineType(EditableDevice):
+
+    def __init__(self, name='SequenceLine', idtag=None, Imax=1, Vnom=1,
+                 R=0, X=0, B=0, R0=0, X0=0, B0=0, CnF=0, CnF0=0, use_conductance: bool = False):
+        """
+        Constructor
+        :param name: name of the model
+        :param Imax: Line rating current in kA
+        :param R: Resistance of positive sequence in Ohm/km
+        :param X: Reactance of positive sequence in Ohm/km
+        :param B: Susceptance of positive sequence in uS/km
+        :param R0: Resistance of zero sequence in Ohm/km
+        :param X0: Reactance of zero sequence in Ohm/km
+        :param B0: Susceptance of zero sequence in uS/km
+        :param CnF: Conductivity of positive sequence in uS/km
+        :param CnF0: Conductivity of zero sequence in uS/km
+        """
+
+        EditableDevice.__init__(self,
+                                name=name,
+                                idtag=idtag,
+                                code="",
+                                device_type=DeviceType.SequenceLineDevice)
+
+        self.Imax = Imax
+        self.Vnom = Vnom
+
+        # impudence and admittance per unit of length
+        self.R = R
+        self.X = X
+        self.B = B
+        self.Cnf = CnF
+
+        self.R0 = R0
+        self.X0 = X0
+        self.B0 = B0
+        self.Cnf0 = CnF0
+
+        self.use_conductance = use_conductance
+
+        self.register(key='Imax', units='kA', tpe=float, definition='Current rating of the line', old_names=['rating'])
+        self.register(key='Vnom', units='kV', tpe=float, definition='Voltage rating of the line')
+        self.register(key='R', units='Ohm/km', tpe=float, definition='Positive-sequence resistance per km')
+        self.register(key='X', units='Ohm/km', tpe=float, definition='Positive-sequence reactance per km')
+        self.register(key='B', units='uS/km', tpe=float, definition='Positive-sequence shunt susceptance per km')
+        self.register(key='R0', units='Ohm/km', tpe=float, definition='Zero-sequence resistance per km')
+        self.register(key='X0', units='Ohm/km', tpe=float, definition='Zero-sequence reactance per km')
+        self.register(key='B0', units='uS/km', tpe=float, definition='Zero-sequence shunt susceptance per km')
+        self.register(key='Cnf', units='nF/km', tpe=float, definition='Positive-sequence shunt conductance per km')
+        self.register(key='Cnf0', units='nF/km', tpe=float, definition='Zero-sequence shunt conductance per km')
+        self.register(key='use_conductance', units='', tpe=bool,
+                      definition='Use conductance? else the susceptance is used')
+
+    def get_values(self, Sbase: float, freq: float, length: float, line_Vnom: float, ):
+        """
+        Get the per-unit values
+        :param Sbase: Base power (MVA, always use 100MVA)
+        :param freq: Frequency (Hz)
+        :param length: length in km
+        :param line_Vnom: Line nominal voltage
+        :return: R (p.u.), x(p.u.), B(p.u.), Rate (MVA)
+        """
+
+        if self.use_conductance:
+            R, X, B, rate = get_line_impedances_with_c(r_ohm=self.R,
+                                                       x_ohm=self.X,
+                                                       c_nf=self.Cnf,
+                                                       length=length, Imax=self.Imax,
+                                                       freq=freq, Sbase=Sbase, Vnom=line_Vnom)
+            R0, X0, B0, _ = get_line_impedances_with_c(r_ohm=self.R0,
+                                                       x_ohm=self.X0,
+                                                       c_nf=self.Cnf0,
+                                                       length=length, Imax=self.Imax,
+                                                       freq=freq, Sbase=Sbase, Vnom=line_Vnom)
+        else:
+            R, X, B, rate = get_line_impedances_with_b(r_ohm=self.R,
+                                                       x_ohm=self.X,
+                                                       b_us=self.B,
+                                                       length=length, Imax=self.Imax,
+                                                       Sbase=Sbase, Vnom=line_Vnom)
+            R0, X0, B0, _ = get_line_impedances_with_b(r_ohm=self.R0,
+                                                       x_ohm=self.X0,
+                                                       b_us=self.B0,
+                                                       length=length, Imax=self.Imax,
+                                                       Sbase=Sbase, Vnom=line_Vnom)
+
+        return R, X, B, R0, X0, B0, rate

{gridcalengine-5.3.4 → gridcalengine-5.3.6}/GridCalEngine/Devices/Branches/transformer.py

@@ -327,10 +327,10 @@ class Transformer2W(ControllableBranchParent):
             # get the transformer impedance in the base of the transformer
             z_series, y_shunt = obj.get_impedances(VH=VH, VL=VL, Sbase=Sbase)
 
-            self.R = np.round(z_series.real, 6)
-            self.X = np.round(z_series.imag, 6)
-            self.G = np.round(y_shunt.real, 6)
-            self.B = np.round(y_shunt.imag, 6)
+            self.R = z_series.real
+            self.X = z_series.imag
+            self.G = y_shunt.real
+            self.B = y_shunt.imag
 
             self.rate = obj.Sn
             self.rate_prof.fill(self.rate)
@@ -354,30 +354,6 @@ class Transformer2W(ControllableBranchParent):
             else:
                 self.template = obj
 
-    def get_save_data(self) -> Union[None, List[str]]:
-        """
-        Return the data that matches the edit_headers
-        :return:
-        """
-        data = list()
-        for property_name, properties in self.registered_properties.items():
-            obj = getattr(self, property_name)
-
-            if properties.tpe == DeviceType.BusDevice:
-                obj = obj.idtag
-
-            elif properties.tpe == DeviceType.TransformerTypeDevice:
-                if obj is None:
-                    obj = ''
-                else:
-                    obj = obj.idtag
-
-            elif properties.tpe not in [str, float, int, bool]:
-                obj = str(obj)
-
-            data.append(obj)
-        return data
-
     def delete_virtual_taps(self):
         """
         Set the HV and LV parameters such that any virtual tap is null
@@ -423,7 +399,7 @@ class Transformer2W(ControllableBranchParent):
 
         return errors
 
-    def fill_design_properties(self, Pcu: float, Pfe: float, I0: float, Vsc: float, Sbase: float):
+    def fill_design_properties(self, Pcu: float, Pfe: float, I0: float, Vsc: float, Sbase: float, round_vals: bool=False):
         """
         Fill R, X, G, B from the short circuit study values
         :param Pcu: copper_losses (kW)
@@ -431,6 +407,7 @@ class Transformer2W(ControllableBranchParent):
         :param I0: No load current in %
         :param Vsc: Short circuit voltage (%)
         :param Sbase: Base power in MVA (take always 100 MVA)
+        :param round_vals: round the values?
         :return: self pointer
         """
         tpe = TransformerType(hv_nominal_voltage=self.HV,
@@ -446,10 +423,16 @@ class Transformer2W(ControllableBranchParent):
 
         z_series, y_shunt = tpe.get_impedances(VH=self.HV, VL=self.LV, Sbase=Sbase)
 
-        self.R = np.round(z_series.real, 6)
-        self.X = np.round(z_series.imag, 6)
-        self.G = np.round(y_shunt.real, 6)
-        self.B = np.round(y_shunt.imag, 6)
+        if round_vals:
+            self.R = np.round(z_series.real, 6)
+            self.X = np.round(z_series.imag, 6)
+            self.G = np.round(y_shunt.real, 6)
+            self.B = np.round(y_shunt.imag, 6)
+        else:
+            self.R = z_series.real
+            self.X = z_series.imag
+            self.G = y_shunt.real
+            self.B = y_shunt.imag
 
         return self
 

{gridcalengine-5.3.4 → gridcalengine-5.3.6}/GridCalEngine/Devices/Branches/transformer_type.py

@@ -3,7 +3,7 @@
 # file, You can obtain one at https://mozilla.org/MPL/2.0/.
 # SPDX-License-Identifier: MPL-2.0
 from typing import Tuple, Union
-from numpy import sqrt
+from numpy import sqrt, real, imag
 from GridCalEngine.enumerations import TapChangerTypes
 from GridCalEngine.Devices.Parents.editable_device import EditableDevice, DeviceType
 from GridCalEngine.Devices.Branches.tap_changer import TapChanger
@@ -297,44 +297,36 @@ def get_impedances(VH_bus: float, VL_bus: float, Sn: float, HV: float, LV: float
     # Shunt impedance (leakage)
     if Pfe > 0.0 and I0 > 0.0:
 
-        rfe = Sn / (Pfe / 1000.0)
+        # rfe = Sn / (Pfe / 1000.0)
+        rm = Sbase / (Pfe / 1000.0)
+        I0 = I0 * Sn / Sbase  # try?
         zm = 1.0 / (I0 / 100.0)
-        val = (1.0 / (zm ** 2)) - (1.0 / (rfe ** 2))
-        if val > 0:
-            xm = 1.0 / sqrt(val)
-            rm = sqrt(xm * xm - zm * zm)
+
+        inside_sqrt = (-zm ** 2 * rm ** 2) / (zm ** 2 - rm ** 2)
+        if inside_sqrt > 0:
+            xm = sqrt(inside_sqrt)
         else:
             xm = 0.0
-            rm = 0.0
-
     else:
-
         rm = 0.0
         xm = 0.0
 
-    # shunt impedance in p.u. of the machine
-    zsh = rm + 1j * xm
-
     # convert impedances from machine per unit to ohms
     z_base_hv = (HV * HV) / Sn
     z_base_lv = (LV * LV) / Sn
 
     z_series_hv = zs * GR_hv1 * z_base_hv  # Ohm
     z_series_lv = zs * (1.0 - GR_hv1) * z_base_lv  # Ohm
-    z_shunt_hv = zsh * GR_hv1 * z_base_hv  # Ohm
-    z_shunt_lv = zsh * (1.0 - GR_hv1) * z_base_lv  # Ohm
 
     # convert impedances from ohms to system per unit
     z_base_hv_sys = (VH_bus * VH_bus) / Sbase
     z_base_lv_sys = (VL_bus * VL_bus) / Sbase
 
     z_series = z_series_hv / z_base_hv_sys + z_series_lv / z_base_lv_sys
-    z_shunt = z_shunt_hv / z_base_hv_sys + z_shunt_lv / z_base_lv_sys
 
-    if z_shunt != 0:
-        y_shunt = 1 / z_shunt
-    else:
-        y_shunt = 0j
+    g = 1 / rm if rm > 0.0 else 0.0
+    b = 1 / xm if xm > 0.0 else 0.0
+    y_shunt = g - 1j * b
 
     return z_series, y_shunt