GridCalEngine 5.1.37__tar.gz → 5.1.39__tar.gz

{GridCalEngine-5.1.37 → GridCalEngine-5.1.39}/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.37 → GridCalEngine-5.1.39}/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.37 → GridCalEngine-5.1.39}/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

{GridCalEngine-5.1.37 → GridCalEngine-5.1.39}/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.37 → GridCalEngine-5.1.39}/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.37 → GridCalEngine-5.1.39}/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.37 → GridCalEngine-5.1.39}/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.37 → GridCalEngine-5.1.39}/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.37 → GridCalEngine-5.1.39}/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.37 → GridCalEngine-5.1.39}/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.37 → GridCalEngine-5.1.39}/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.37 → GridCalEngine-5.1.39}/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.37 → GridCalEngine-5.1.39}/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

{GridCalEngine-5.1.37 → GridCalEngine-5.1.39}/GridCalEngine/Devices/Fluid/fluid_node.py

@@ -58,21 +58,21 @@ class FluidNode(PhysicalDevice):
                                 code=code,
                                 device_type=DeviceType.FluidNodeDevice)
 
-        self.min_level = min_level  # hm3
-        self.max_level = max_level  # hm3
-        self.max_soc = max_soc  # p.u.
-        self.min_soc = min_soc  # p.u.
-        self.initial_level = current_level  # hm3
-        self.spillage_cost = spillage_cost  # m3/s
-        self.inflow = inflow  # m3/s
+        self.min_level = float(min_level)  # hm3
+        self.max_level = float(max_level)  # hm3
+        self.max_soc = float(max_soc)  # p.u.
+        self.min_soc = float(min_soc)  # p.u.
+        self.initial_level = float(current_level)  # hm3
+        self.spillage_cost = float(spillage_cost)  # m3/s
+        self.inflow = float(inflow)  # m3/s
         self._bus: Bus = bus
         self.build_status = build_status
 
-        self._inflow_prof = Profile(default_value=inflow, data_type=float)  # m3/s
-        self._spillage_cost_prof = Profile(default_value=spillage_cost, data_type=float)  # e/(m3/s)
+        self._inflow_prof = Profile(default_value=self.inflow, data_type=float)  # m3/s
+        self._spillage_cost_prof = Profile(default_value=self.spillage_cost, data_type=float)  # e/(m3/s)
 
-        self._max_soc_prof = Profile(default_value=max_soc, data_type=float)  # p.u.
-        self._min_soc_prof = Profile(default_value=min_soc, data_type=float)  # p.u.
+        self._max_soc_prof = Profile(default_value=self.max_soc, data_type=float)  # p.u.
+        self._min_soc_prof = Profile(default_value=self.min_soc, data_type=float)  # p.u.
 
         self.register(key='min_level', units='hm3', tpe=float,
                       definition="Minimum amount of fluid at the node/reservoir")

{GridCalEngine-5.1.37 → GridCalEngine-5.1.39}/GridCalEngine/Devices/Fluid/fluid_path.py

@@ -55,8 +55,8 @@ class FluidPath(PhysicalDevice):
 
         self.source = source
         self.target = target
-        self.min_flow = min_flow
-        self.max_flow = max_flow
+        self.min_flow = float(min_flow)
+        self.max_flow = float(max_flow)
 
         # Line locations
         self._locations: LineLocations = LineLocations()

{GridCalEngine-5.1.37 → GridCalEngine-5.1.39}/GridCalEngine/Devices/Injections/battery.py

@@ -157,27 +157,27 @@ class Battery(Generator):
         # type of this device
         self.device_type = DeviceType.BatteryDevice
 
-        self.charge_efficiency = charge_efficiency
+        self.charge_efficiency = float(charge_efficiency)
 
-        self.discharge_efficiency = discharge_efficiency
+        self.discharge_efficiency = float(discharge_efficiency)
 
-        self.max_soc = max_soc
+        self.max_soc = float(max_soc)
 
-        self.min_soc = min_soc
+        self.min_soc = float(min_soc)
 
         self.min_soc_charge = (self.max_soc + self.min_soc) / 2  # SoC state to force the battery charge
 
-        self.charge_per_cycle = charge_per_cycle  # charge 10% per cycle
+        self.charge_per_cycle = float(charge_per_cycle)  # charge 10% per cycle
 
-        self.discharge_per_cycle = discharge_per_cycle
+        self.discharge_per_cycle = float(discharge_per_cycle)
 
-        self.min_energy = Enom * self.min_soc
+        self.Enom = float(Enom)
 
-        self.Enom = Enom
+        self.soc_0 = float(soc)
 
-        self.soc_0 = soc
+        self.soc = float(soc)
 
-        self.soc = soc
+        self.min_energy = self.Enom * self.min_soc
 
         self.energy = self.Enom * self.soc
 

{GridCalEngine-5.1.37 → GridCalEngine-5.1.39}/GridCalEngine/Devices/Injections/controllable_shunt.py

@@ -82,8 +82,8 @@ class ControllableShunt(ShuntParent):
                              build_status=build_status,
                              device_type=DeviceType.ControllableShuntDevice)
 
-        self.is_controlled = is_controlled
-        self.is_nonlinear = is_nonlinear
+        self.is_controlled = bool(is_controlled)
+        self.is_nonlinear = bool(is_nonlinear)
         self._g_steps = np.zeros(number_of_steps)
         self._b_steps = np.zeros(number_of_steps)
 
@@ -93,17 +93,17 @@ class ControllableShunt(ShuntParent):
             self._g_steps[i] = g_per_step * (i + 1)
             self._b_steps[i] = b_per_step * (i + 1)
 
-        self._step = step
-        self._step_prof = Profile(default_value=step, data_type=int)
+        self._step = int(step)
+        self._step_prof = Profile(default_value=self._step, data_type=int)
 
         self.control_bus = control_bus
         self._control_bus_prof = Profile(default_value=control_bus, data_type=DeviceType.BusDevice)
 
         # Voltage module set point (p.u.)
-        self.Vset = vset
+        self.Vset = float(vset)
 
         # voltage set profile for this load in p.u.
-        self._Vset_prof = Profile(default_value=vset, data_type=float)
+        self._Vset_prof = Profile(default_value=self.Vset, data_type=float)
 
         self.register(key='is_nonlinear', units='', tpe=bool, definition='Is non-linear?')
         self.register(key='g_steps', units='', tpe=SubObjectType.Array,

{GridCalEngine-5.1.37 → GridCalEngine-5.1.39}/GridCalEngine/Devices/Injections/current_injection.py

@@ -60,11 +60,11 @@ class CurrentInjection(InjectionParent):
                                  build_status=build_status,
                                  device_type=DeviceType.CurrentInjectionDevice)
 
-        self.Ir = Ir
-        self.Ii = Ii
+        self.Ir = float(Ir)
+        self.Ii = float(Ii)
 
-        self._Ir_prof = Profile(default_value=Ir, data_type=float)
-        self._Ii_prof = Profile(default_value=Ii, data_type=float)
+        self._Ir_prof = Profile(default_value=self.Ir, data_type=float)
+        self._Ii_prof = Profile(default_value=self.Ii, data_type=float)
 
         self.register(key='Ir', units='MW', tpe=float,
                       definition='Active power of the current component at V=1.0 p.u.',