GridCalEngine 5.1.36__tar.gz → 5.1.38__tar.gz

{GridCalEngine-5.1.36 → GridCalEngine-5.1.38}/GridCalEngine/Devices/Branches/dc_line.py

@@ -109,25 +109,25 @@ class DcLine(BranchParent):
         self.measurements = list()
 
         # line length in km
-        self.length = length
+        self.length = float(length)
 
         # line impedance tolerance
-        self.tolerance = tolerance
+        self.tolerance = float(tolerance)
 
         # short circuit impedance
-        self.r_fault = r_fault
-        self.fault_pos = fault_pos
+        self.r_fault = float(r_fault)
+        self.fault_pos = float(fault_pos)
 
         # total impedance and admittance in p.u.
-        self.R = r
+        self.R = float(r)
 
         # Conductor base and operating temperatures in ºC
-        self.temp_base = temp_base
-        self.temp_oper = temp_oper
+        self.temp_base = float(temp_base)
+        self.temp_oper = float(temp_oper)
         self._temp_oper_prof = Profile(default_value=temp_oper, data_type=float)
 
         # Conductor thermal constant (1/ºC)
-        self.alpha = alpha
+        self.alpha = float(alpha)
 
         # type template
         self.template = template

{GridCalEngine-5.1.36 → GridCalEngine-5.1.38}/GridCalEngine/Devices/Branches/hvdc_line.py

@@ -191,30 +191,30 @@ class HvdcLine(BranchParent):
                               device_type=DeviceType.HVDCLineDevice)
 
         # line length in km
-        self.length = length
+        self.length = float(length)
 
-        self.dispatchable = dispatchable
+        self.dispatchable = bool(dispatchable)
 
-        self.Pset = Pset
+        self.Pset = float(Pset)
 
-        self.r = r
+        self.r = float(r)
 
-        self.angle_droop = angle_droop
+        self.angle_droop = float(angle_droop)
 
-        self.loss_factor = loss_factor
+        self.loss_factor = float(loss_factor)
 
-        self.mttf = mttf
+        self.mttf = float(mttf)
 
-        self.mttr = mttr
+        self.mttr = float(mttr)
 
-        self.Vset_f = Vset_f
-        self.Vset_t = Vset_t
+        self.Vset_f = float(Vset_f)
+        self.Vset_t = float(Vset_t)
 
         # converter / inverter firing angles
-        self.min_firing_angle_f = min_firing_angle_f
-        self.max_firing_angle_f = max_firing_angle_f
-        self.min_firing_angle_t = min_firing_angle_t
-        self.max_firing_angle_t = max_firing_angle_t
+        self.min_firing_angle_f = float(min_firing_angle_f)
+        self.max_firing_angle_f = float(max_firing_angle_f)
+        self.min_firing_angle_t = float(min_firing_angle_t)
+        self.max_firing_angle_t = float(max_firing_angle_t)
 
         self.Qmin_f, self.Qmax_f = firing_angles_to_reactive_limits(self.Pset,
                                                                     self.min_firing_angle_f,
@@ -224,13 +224,13 @@ class HvdcLine(BranchParent):
                                                                     self.min_firing_angle_t,
                                                                     self.max_firing_angle_t)
 
-        self.capex = capex
+        self.capex = float(capex)
 
-        self.opex = opex
+        self.opex = float(opex)
 
         self.build_status = build_status
 
-        self.control_mode = control_mode
+        self.control_mode: HvdcControlType = control_mode
 
         self._Pset_prof: Vec = Profile(default_value=Pset, data_type=float)
         self._active_prof: IntVec = Profile(default_value=active, data_type=bool)

{GridCalEngine-5.1.36 → GridCalEngine-5.1.38}/GridCalEngine/Devices/Branches/line.py

@@ -104,36 +104,36 @@ class Line(BranchParent):
                               device_type=DeviceType.LineDevice)
 
         # line length in km
-        self._length = length
+        self._length = float(length)
 
         # line impedance tolerance
-        self.tolerance = tolerance
+        self.tolerance = float(tolerance)
 
         # short circuit impedance
-        self.r_fault = r_fault
-        self.x_fault = x_fault
-        self.fault_pos = fault_pos
+        self.r_fault = float(r_fault)
+        self.x_fault = float(x_fault)
+        self.fault_pos = float(fault_pos)
 
         # total impedance and admittance in p.u.
-        self.R = r
-        self.X = x
-        self.B = b
+        self.R = float(r)
+        self.X = float(x)
+        self.B = float(b)
 
-        self.R0 = r0
-        self.X0 = x0
-        self.B0 = b0
+        self.R0 = float(r0)
+        self.X0 = float(x0)
+        self.B0 = float(b0)
 
-        self.R2 = r2
-        self.X2 = x2
-        self.B2 = b2
+        self.R2 = float(r2)
+        self.X2 = float(x2)
+        self.B2 = float(b2)
 
         # Conductor base and operating temperatures in ºC
-        self.temp_base = temp_base
-        self.temp_oper = temp_oper
+        self.temp_base = float(temp_base)
+        self.temp_oper = float(temp_oper)
         self._temp_oper_prof = Profile(default_value=temp_oper, data_type=float)
 
         # Conductor thermal constant (1/ºC)
-        self.alpha = alpha
+        self.alpha = float(alpha)
 
         # type template
         self.template: Union[OverheadLineType, SequenceLineType, UndergroundLineType] = template
@@ -394,33 +394,43 @@ class Line(BranchParent):
         elm.temperature_prof = self.temp_oper_prof
         return elm
 
-    def fill_design_properties(self, r_ohm, x_ohm, c_nf, length, Imax, freq, Sbase):
+    def fill_design_properties(self, r_ohm, x_ohm, c_nf, length, Imax, freq, Sbase, apply_to_profile: bool = True,):
         """
         Fill R, X, B from not-in-per-unit parameters
-        :param r_ohm: Resistance per km in OHM
-        :param x_ohm: Reactance per km in OHM
-        :param c_nf: Capacitance per km in nF
+        :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: lenght 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 apply_to_profile: modify the profile is checked
         """
-        R = r_ohm * length
-        X = x_ohm * length
-        # impedance = 1 / (2 * pi * f * c), susceptance = (2 * pi * f * c)
-        B = (2 * np.pi * freq * c_nf * 1e-9) * length
+        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 / Zbase, 6)
-        self.X = np.round(X / Zbase, 6)
-        self.B = np.round(B / Ybase, 6)
-        self.rate = np.round(Imax * Vf * 1.73205080757, 6)  # nominal power in MVA = kA * kV * sqrt(3)
+        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)
+
+        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
 
+        if apply_to_profile:
+            prof_old = self.rate_prof.toarray()
+            self.rate_prof.set(prof_old * new_rate / old_rate)
+
     def get_virtual_taps(self) -> Tuple[float, float]:
         """
         Get the branch virtual taps

{GridCalEngine-5.1.36 → GridCalEngine-5.1.38}/GridCalEngine/Devices/Branches/overhead_line_type.py

@@ -123,12 +123,12 @@ class OverheadLineType(EditableDevice):
 
         self.register(key='earth_resistivity', units='Ohm/m3', tpe=float, definition='Earth resistivity')
         self.register(key='frequency', units='Hz', tpe=float, definition='Frequency')
-        self.register(key='R1', units='Ohm/km', tpe=float, definition='Positive sequence resistance')
-        self.register(key='X1', units='Ohm/km', tpe=float, definition='Positive sequence reactance')
-        self.register(key='Bsh1', units='uS/km', tpe=float, definition='Positive sequence shunt susceptance')
-        self.register(key='R0', units='Ohm/km', tpe=float, definition='Zero-sequence resistance')
-        self.register(key='X0', units='Ohm/km', tpe=float, definition='Zero sequence reactance')
-        self.register(key='Bsh0', units='uS/km', tpe=float, definition='Zero sequence shunt susceptance')
+        self.register(key='R1', units='Ohm/Km', tpe=float, definition='Positive sequence resistance')
+        self.register(key='X1', units='Ohm/Km', tpe=float, definition='Positive sequence reactance')
+        self.register(key='Bsh1', units='uS/Km', tpe=float, definition='Positive sequence shunt susceptance')
+        self.register(key='R0', units='Ohm/Km', tpe=float, definition='Zero-sequence resistance')
+        self.register(key='X0', units='Ohm/Km', tpe=float, definition='Zero sequence reactance')
+        self.register(key='Bsh0', units='uS/Km', tpe=float, definition='Zero sequence shunt susceptance')
         self.register(key='Imax', units='kA', tpe=float, definition='Current rating of the tower', old_names=['rating'])
         self.register(key='Vnom', units='kV', tpe=float, definition='Voltage rating of the line')
 
@@ -382,9 +382,9 @@ def z_ii(r_i, x_i, h_i, gmr_i, f, rho):
     """
     w = 2 * pi * f  # rad
 
-    mu_0 = 4 * pi * 1e-4  # H/km
+    mu_0 = 4 * pi * 1e-4  # H/Km
 
-    mu_0_2pi = 2e-4  # H/km
+    mu_0_2pi = 2e-4  # H/Km
 
     p = sqrt(rho / (1j * w * mu_0))
 
@@ -408,9 +408,9 @@ def z_ij(x_i, x_j, h_i, h_j, d_ij, f, rho):
     """
     w = 2 * pi * f  # rad
 
-    mu_0 = 4 * pi * 1e-4  # H/km
+    mu_0 = 4 * pi * 1e-4  # H/Km
 
-    mu_0_2pi = 2e-4  # H/km
+    mu_0_2pi = 2e-4  # H/Km
 
     p = sqrt(rho / (1j * w * mu_0))
 
@@ -585,11 +585,11 @@ def calc_y_matrix(wires: list, f=50, rho=100):
     # dictionary with the wire indices per phase
     phases_set = set()
 
-    # 1 / (2 * pi * e0) in km/F
+    # 1 / (2 * pi * e0) in Km/F
     e_air = 1.00058986
-    e_0 = 8.854187817e-9  # F/km
+    e_0 = 8.854187817e-9  # F/Km
     e = e_0 * e_air
-    one_two_pi_e0 = 1 / (2 * pi * e)  # km/F
+    one_two_pi_e0 = 1 / (2 * pi * e)  # Km/F
 
     phases_abcn = np.zeros(n, dtype=int)
 

{GridCalEngine-5.1.36 → GridCalEngine-5.1.38}/GridCalEngine/Devices/Branches/switch.py

@@ -74,14 +74,14 @@ class Switch(BranchParent):
                               device_type=DeviceType.SwitchDevice)
 
         # total impedance and admittance in p.u.
-        self.R = r
-        self.X = x
+        self.R = float(r)
+        self.X = float(x)
 
         # self.is_open = is_open
-        self.retained = retained
+        self.retained = bool(retained)
 
-        self.normal_open = normal_open
-        self.rated_current = rated_current      # TODO handling kA
+        self.normal_open = bool(normal_open)
+        self.rated_current = float(rated_current)
 
         self.register(key='R', units='pu', tpe=float, definition='Positive-sequence resistance')
         self.register(key='X', units='pu', tpe=float, definition='Positive-sequence reactance')
@@ -93,7 +93,7 @@ class Switch(BranchParent):
 
         self.register(key='normal_open', units="", tpe=bool,
                       definition='Normal position of the switch')
-        self.register(key='rated_current', units="kA", tpe=float,
+        self.register(key='rated_current', units="KA", tpe=float,
                       definition='Rated current of the switch device.')
 
     def copy(self, bus_dict=None):

{GridCalEngine-5.1.36 → GridCalEngine-5.1.38}/GridCalEngine/Devices/Branches/tap_changer.py

@@ -42,17 +42,17 @@ class TapChanger:
         :param tc_type: Tap changer type
         """
 
-        self.asymmetry_angle = asymmetry_angle  # assymetry angle (Theta)
-        self._total_positions = total_positions  # total number of positions
-        self.dV = dV  # voltage increment in p.u.
-        self.neutral_position = neutral_position  # neutral position
-        self._tap_position = neutral_position  # index with respect to the neutral position
-        self.tc_type = tc_type  # tap changer mode
+        self.asymmetry_angle = float(asymmetry_angle)  # assymetry angle (Theta)
+        self._total_positions = int(total_positions)  # total number of positions
+        self.dV = float(dV)  # voltage increment in p.u.
+        self.neutral_position = int(neutral_position)  # neutral position
+        self._tap_position = int(neutral_position)  # index with respect to the neutral position
+        self.tc_type: TapChangerTypes = tc_type  # tap changer mode
 
         # Calculated arrays
-        self._ndv = np.zeros(total_positions)
-        self._tau_array = np.zeros(total_positions)
-        self._m_array = np.zeros(total_positions)
+        self._ndv = np.zeros(self._total_positions)
+        self._tau_array = np.zeros(self._total_positions)
+        self._m_array = np.zeros(self._total_positions)
         self.recalc()
 
     @property

{GridCalEngine-5.1.36 → GridCalEngine-5.1.38}/GridCalEngine/Devices/Branches/transformer.py

@@ -14,6 +14,7 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+from __future__ import annotations
 
 import numpy as np
 from typing import Tuple, Union, List
@@ -204,27 +205,27 @@ class Transformer2W(ControllableBranchParent):
                                           tc_type=tc_type)
 
         # set the high and low voltage values
-        self.HV = HV
-        self.LV = LV
+        self.HV: None | float = None if HV is None else float(HV)
+        self.LV: None | float = None if LV is None else float(LV)
 
         if self.bus_from and self.bus_to:
             self.set_hv_and_lv(HV, LV)
 
-        self.Sn = nominal_power
+        self.Sn = float(nominal_power)
 
-        self.Pcu = copper_losses
+        self.Pcu = float(copper_losses)
 
-        self.Pfe = iron_losses
+        self.Pfe = float(iron_losses)
 
-        self.I0 = no_load_current
+        self.I0 = float(no_load_current)
 
-        self.Vsc = short_circuit_voltage
+        self.Vsc = float(short_circuit_voltage)
 
         # connection type
-        self.conn = conn
+        self.conn: WindingsConnection = conn
 
         # type template
-        self.template = template
+        self.template: TransformerType = template
 
         # association with transformer templates
         self.possible_transformer_types: Associations = Associations(device_type=DeviceType.TransformerTypeDevice)

{GridCalEngine-5.1.36 → GridCalEngine-5.1.38}/GridCalEngine/Devices/Branches/transformer3w.py

@@ -94,31 +94,31 @@ class Transformer3W(PhysicalDevice):
         self._bus2 = bus2
         self._bus3 = bus3
 
-        self.active = active
-        self._active_prof = Profile(default_value=active, data_type=bool)
+        self.active = bool(active)
+        self._active_prof = Profile(default_value=self.active, data_type=bool)
 
-        self._V1 = V1
-        self._V2 = V2
-        self._V3 = V3
+        self._V1 = float(V1)
+        self._V2 = float(V2)
+        self._V3 = float(V3)
 
-        self._r12 = r12
-        self._r23 = r23
-        self._r31 = r31
+        self._r12 = float(r12)
+        self._r23 = float(r23)
+        self._r31 = float(r31)
 
-        self._x12 = x12
-        self._x23 = x23
-        self._x31 = x31
+        self._x12 = float(x12)
+        self._x23 = float(x23)
+        self._x31 = float(x31)
 
-        self._rate12 = rate12
-        self._rate23 = rate23
-        self._rate31 = rate31
+        self._rate12 = float(rate12)
+        self._rate23 = float(rate23)
+        self._rate31 = float(rate31)
 
         self.winding1 = Winding(bus_from=self.bus0, bus_to=bus1, HV=V1, LV=1.0, name=name + "_W1")
         self.winding2 = Winding(bus_from=self.bus0, bus_to=bus2, HV=V2, LV=1.0, name=name + "_W2")
         self.winding3 = Winding(bus_from=self.bus0, bus_to=bus3, HV=V3, LV=1.0, name=name + "_W3")
 
-        self.x = x
-        self.y = y
+        self.x = float(x)
+        self.y = float(y)
 
         self.register(key='bus0', units='', tpe=DeviceType.BusDevice, definition='Middle point connection bus.',
                       editable=False)

{GridCalEngine-5.1.36 → GridCalEngine-5.1.38}/GridCalEngine/Devices/Branches/transformer_type.py

@@ -65,23 +65,23 @@ class TransformerType(EditableDevice):
                                 code='',
                                 device_type=DeviceType.TransformerTypeDevice)
 
-        self.HV = hv_nominal_voltage
+        self.HV = float(hv_nominal_voltage)
 
-        self.LV = lv_nominal_voltage
+        self.LV = float(lv_nominal_voltage)
 
-        self.Sn = nominal_power
+        self.Sn = float(nominal_power)
 
-        self.Pcu = copper_losses
+        self.Pcu = float(copper_losses)
 
-        self.Pfe = iron_losses
+        self.Pfe = float(iron_losses)
 
-        self.I0 = no_load_current
+        self.I0 = float(no_load_current)
 
-        self.Vsc = short_circuit_voltage
+        self.Vsc = float(short_circuit_voltage)
 
-        self.GR_hv1 = gr_hv1
+        self.GR_hv1 = float(gr_hv1)
 
-        self.GX_hv1 = gx_hv1
+        self.GX_hv1 = float(gx_hv1)
 
         # The tap changer parameters are stored and used with the help of the TapChanger object
         self._tap_changer = TapChanger(total_positions=total_positions,

{GridCalEngine-5.1.36 → GridCalEngine-5.1.38}/GridCalEngine/Devices/Branches/underground_line_type.py

@@ -14,14 +14,16 @@
 # You should have received a copy of the GNU Lesser General Public License
 # along with this program; if not, write to the Free Software Foundation,
 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
+from __future__ import annotations
 import numpy as np
 from GridCalEngine.Devices.Parents.editable_device import EditableDevice, DeviceType
 
 
 class UndergroundLineType(EditableDevice):
 
-    def __init__(self, name='UndergroundLine', idtag=None, Imax=1, Vnom=1, R=0, X=0, B=0, R0=0, X0=0, B0=0):
+    def __init__(self, name: str = 'UndergroundLine', idtag: None | str = None, Imax: float = 1.0,
+                 Vnom: float = 1.0, R: float = 0.0, X: float = 0.0, B: float = 0.0,
+                 R0: float = 0.0, X0: float = 0.0, B0: float = 0.0) -> None:
         """
         Constructor
         :param name: name of the device
@@ -39,17 +41,17 @@ class UndergroundLineType(EditableDevice):
                                 code='',
                                 device_type=DeviceType.UnderGroundLineDevice)
 
-        self.Imax = Imax
-        self.Vnom = Vnom
+        self.Imax = float(Imax)
+        self.Vnom = float(Vnom)
 
         # impudence and admittance per unit of length
-        self.R = R
-        self.X = X
-        self.B = B
+        self.R = float(R)
+        self.X = float(X)
+        self.B = float(B)
 
-        self.R0 = R0
-        self.X0 = X0
-        self.B0 = B0
+        self.R0 = float(R0)
+        self.X0 = float(X0)
+        self.B0 = float(B0)
 
         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')

{GridCalEngine-5.1.36 → GridCalEngine-5.1.38}/GridCalEngine/Devices/Branches/upfc.py

@@ -96,24 +96,24 @@ class UPFC(BranchParent):
                               device_type=DeviceType.UpfcDevice)
 
         # total impedance and admittance in p.u.
-        self.Rs = rs
-        self.Xs = xs
-        self.Rsh = rp
-        self.Xsh = xp
+        self.Rs = float(rs)
+        self.Xs = float(xs)
+        self.Rsh = float(rp)
+        self.Xsh = float(xp)
 
-        self.Rs0 = rs0
-        self.Xs0 = xs0
-        self.Rsh0 = rp0
-        self.Xsh0 = xp0
+        self.Rs0 = float(rs0)
+        self.Xs0 = float(xs0)
+        self.Rsh0 = float(rp0)
+        self.Xsh0 = float(xp0)
 
-        self.Rs2 = rs2
-        self.Xs2 = xs2
-        self.Rsh2 = rp2
-        self.Xsh2 = xp2
+        self.Rs2 = float(rs2)
+        self.Xs2 = float(xs2)
+        self.Rsh2 = float(rp2)
+        self.Xsh2 = float(xp2)
 
-        self.Vsh = vp
-        self.Pfset = Pset
-        self.Qfset = Qset
+        self.Vsh = float(vp)
+        self.Pfset = float(Pset)
+        self.Qfset = float(Qset)
 
         self.register(key='Rs', units='p.u.', tpe=float, definition='Series positive sequence resistance.')
         self.register(key='Xs', units='p.u.', tpe=float, definition='Series positive sequence reactance.')
@@ -132,12 +132,24 @@ class UPFC(BranchParent):
         self.register(key='Qfset', units='MVAr', tpe=float, definition='Active power set point.')
 
     def get_ysh1(self):
+        """
+
+        :return:
+        """
         return 1.0 / complex(self.Rsh + 1e-20, self.Xsh)
 
     def get_ysh0(self):
+        """
+
+        :return:
+        """
         return 1.0 / complex(self.Rsh0 + 1e-20, self.Xsh0)
 
     def get_ysh2(self):
+        """
+
+        :return:
+        """
         return 1.0 / complex(self.Rsh2 + 1e-20, self.Xsh2)
 
     def get_max_bus_nominal_voltage(self):

{GridCalEngine-5.1.36 → GridCalEngine-5.1.38}/GridCalEngine/Devices/Branches/vsc.py

@@ -190,23 +190,23 @@ class VSC(ControllableBranchParent):
             self.bus_from = None
             self.bus_to = None
 
-        self.G0sw = G0sw
-        self.Beq = Beq
-        self.tap_module = tap_module
-        self.tap_module_max = tap_module_max
-        self.tap_module_min = tap_module_min
+        self.G0sw = float(G0sw)
+        self.Beq = float(Beq)
+        self.tap_module = float(tap_module)
+        self.tap_module_max = float(tap_module_max)
+        self.tap_module_min = float(tap_module_min)
 
-        self.k = k
-        self.tap_phase = tap_phase
-        self.tap_phase_max = tap_phase_max
-        self.tap_phase_min = tap_phase_min
-        self.Beq_min = Beq_min
-        self.Beq_max = Beq_max
+        self.k = float(k)
+        self.tap_phase = float(tap_phase)
+        self.tap_phase_max = float(tap_phase_max)
+        self.tap_phase_min = float(tap_phase_min)
+        self.Beq_min = float(Beq_min)
+        self.Beq_max = float(Beq_max)
 
-        self.kdp = kdp
-        self.alpha1 = alpha1
-        self.alpha2 = alpha2
-        self.alpha3 = alpha3
+        self.kdp = float(kdp)
+        self.alpha1 = float(alpha1)
+        self.alpha2 = float(alpha2)
+        self.alpha3 = float(alpha3)
 
         self.register(key='G0sw', units='p.u.', tpe=float, definition='Inverter losses.')
         self.register(key='Beq', units='p.u.', tpe=float, definition='Total shunt susceptance.')

{GridCalEngine-5.1.36 → GridCalEngine-5.1.38}/GridCalEngine/Devices/Branches/wire.py

@@ -53,11 +53,11 @@ class Wire(EditableDevice):
         # self.wire_name = name
         self._stranding = str(stranding)
         self._material = str(material)
-        self.diameter = diameter
-        self.R = r
-        self.X = x
-        self.GMR = gmr
-        self.max_current = max_current
+        self.diameter = float(diameter)
+        self.R = float(r)
+        self.X = float(x)
+        self.GMR = float(gmr)
+        self.max_current = float(max_current)
 
         self.register(key='R', units='Ohm/km', tpe=float, definition='resistance of the conductor', old_names=['r'])
         self.register(key='X', units='Ohm/km', tpe=float, definition='reactance of the conductor', old_names=['x'])

{GridCalEngine-5.1.36 → GridCalEngine-5.1.38}/GridCalEngine/Devices/Fluid/fluid_injection_template.py

@@ -52,8 +52,8 @@ class FluidInjectionTemplate(PhysicalDevice):
                                 code=code,
                                 device_type=device_type)
 
-        self.efficiency = efficiency  # MWh/m3
-        self.max_flow_rate = max_flow_rate  # m3/s
+        self.efficiency = float(efficiency)  # MWh/m3
+        self.max_flow_rate = float(max_flow_rate)  # m3/s
         self._plant: FluidNode = plant
         self._generator: Generator = generator
         self.build_status = build_status