GridCalEngine 5.3.3__tar.gz → 5.3.5__tar.gz

{gridcalengine-5.3.3 → gridcalengine-5.3.5}/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.3 → gridcalengine-5.3.5}/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.3 → gridcalengine-5.3.5}/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.3 → gridcalengine-5.3.5}/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.3 → gridcalengine-5.3.5}/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.3 → gridcalengine-5.3.5}/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.5/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.3 → gridcalengine-5.3.5}/GridCalEngine/Devices/Branches/transformer.py

@@ -423,7 +423,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=False):
         """
         Fill R, X, G, B from the short circuit study values
         :param Pcu: copper_losses (kW)
@@ -446,10 +446,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:
+            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.3 → gridcalengine-5.3.5}/GridCalEngine/Devices/Branches/transformer_type.py

@@ -300,6 +300,7 @@ def get_impedances(VH_bus: float, VL_bus: float, Sn: float, HV: float, LV: float
         rfe = Sn / (Pfe / 1000.0)
         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)

{gridcalengine-5.3.3 → gridcalengine-5.3.5}/GridCalEngine/Devices/Injections/controllable_shunt.py

@@ -26,6 +26,10 @@ class ControllableShunt(ShuntParent):
                  step: int = 1,
                  g_per_step: float = 0.0,
                  b_per_step: float = 0.0,
+                 Bmin: float = -9999.0,
+                 Bmax: float = 9999.0,
+                 Gmin: float = -9999.0,
+                 Gmax: float = 9999.0,
                  Cost: float = 1200.0,
                  active: bool = True,
                  G: float = 1e-20,
@@ -74,7 +78,22 @@ class ControllableShunt(ShuntParent):
         self.is_controlled = bool(is_controlled)
         self.is_nonlinear = bool(is_nonlinear)
 
-        self._active_steps = np.ones(number_of_steps, dtype=int)
+        self.Bmin = Bmin
+        self.Bmax = Bmax
+
+        self.Gmin = Gmin
+        self.Gmax = Gmax
+
+        if number_of_steps > 0:
+            self.g_per_step = (self.Gmin + self.Gmax) / number_of_steps
+            self.b_per_step = (self.Bmin + self.Bmax) / number_of_steps
+            self._active_steps = np.ones(number_of_steps, dtype=int)
+
+        else:
+            self.g_per_step = 0
+            self.b_per_step = 0
+            self._active_steps = np.ones(0, dtype=int)
+
         self._g_steps = np.full(number_of_steps, g_per_step)
         self._b_steps = np.full(number_of_steps, b_per_step)
 
@@ -98,6 +117,18 @@ class ControllableShunt(ShuntParent):
         self.register(key='b_steps', units='MVAr@v=1p.u.', tpe=SubObjectType.Array,
                       definition='Susceptance steps', editable=False)
 
+        self.register(key='Gmax', units='MW', tpe=float,
+                      definition='Maximum conductance', editable=True)
+
+        self.register(key='Gmin', units='MW', tpe=float,
+                      definition='Minimum conductance', editable=True)
+
+        self.register(key='Bmax', units='MVAr', tpe=float,
+                      definition='Maximum susceptance', editable=True)
+
+        self.register(key='Bmin', units='MVAr', tpe=float,
+                      definition='Minimum susceptance', editable=True)
+
         self.register(key='active_steps', units='', tpe=SubObjectType.Array,
                       definition='steps active?', editable=False)
 
@@ -132,27 +163,27 @@ class ControllableShunt(ShuntParent):
 
             self._step = int(value)
 
-    @property
-    def Bmin(self):
-        """
-
-        :return:
-        """
-        if len(self._b_steps):
-            return self._b_steps[0] * self._active_steps[0]
-        else:
-            return -9999.0
-
-    @property
-    def Bmax(self):
-        """
-
-        :return:
-        """
-        if len(self._b_steps):
-            return np.sum(self._b_steps * self._active_steps)
-        else:
-            return 9999.0
+    # @property
+    # def Bmin(self):
+    #     """
+    #
+    #     :return:
+    #     """
+    #     if len(self._b_steps):
+    #         return self._b_steps[0] * self._active_steps[0]
+    #     else:
+    #         return -9999.0
+    #
+    # @property
+    # def Bmax(self):
+    #     """
+    #
+    #     :return:
+    #     """
+    #     if len(self._b_steps):
+    #         return np.sum(self._b_steps * self._active_steps)
+    #     else:
+    #         return 9999.0
 
     @property
     def g_steps(self):
@@ -166,6 +197,8 @@ class ControllableShunt(ShuntParent):
     def g_steps(self, value: np.ndarray):
         assert isinstance(value, np.ndarray)
         self._g_steps = value
+        # self.Gmax = value.max()
+        # self.Gmin = value.min()
 
     @property
     def active_steps(self):
@@ -229,6 +262,8 @@ class ControllableShunt(ShuntParent):
     def b_steps(self, value: np.ndarray):
         assert isinstance(value, np.ndarray)
         self._b_steps = value
+        # self.Bmax = value.max()
+        # self.Bmin = value.min()
 
     @property
     def Vset_prof(self) -> Profile:

{gridcalengine-5.3.3 → gridcalengine-5.3.5}/GridCalEngine/Devices/Parents/branch_parent.py

@@ -503,16 +503,6 @@ class BranchParent(PhysicalDevice):
         else:
             return False
 
-    def apply_template(self, obj, Sbase, logger: Logger):
-        """
-        Virtual function to apply template
-        :param obj:
-        :param Sbase
-        :param logger
-        :return:
-        """
-        pass
-
     def get_substation_from(self) -> Union[Substation, None]:
         """
         Try to get the substation at the From side

{gridcalengine-5.3.3 → gridcalengine-5.3.5}/GridCalEngine/Devices/Parents/editable_device.py

@@ -744,7 +744,7 @@ class EditableDevice:
         Delete the object profiles (set all to None)
         """
         for magnitude in self.properties_with_profile.keys():
-            self.get_profile(magnitude=magnitude).resize(0)
+            self.get_profile(magnitude=magnitude).clear()
 
     def set_profile_values(self, t):
         """

{gridcalengine-5.3.3 → gridcalengine-5.3.5}/GridCalEngine/Devices/multi_circuit.py

@@ -390,7 +390,7 @@ class MultiCircuit(Assets):
         logger = Logger()
         for branch in self._lines:
             if branch.template is not None:
-                branch.apply_template(branch.template, self.Sbase, logger=logger)
+                branch.apply_template(branch.template, self.Sbase, freq=self.fBase, logger=logger)
 
         for branch in self._transformers2w:
             if branch.template is not None:

{gridcalengine-5.3.3 → gridcalengine-5.3.5}/GridCalEngine/Devices/profile.py

@@ -117,6 +117,15 @@ class Profile:
         if arr is not None:
             self.set(arr=arr)
 
+    def clear(self):
+        """
+        Clear the profile
+        :return:
+        """
+        self._sparse_array: Union[SparseArray, None] = None
+        self._dense_array: Union[NumericVec, None] = None
+        self._initialized: bool = False
+
     def info(self):
         """
         Return dictionary with information about the profile object and its content