# 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 __future__ import annotations
from typing import Union, Tuple
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
from VeraGridEngine.Templates.Rms.load_rms_template import get_load_rms_template
from VeraGridEngine.enumerations import DeviceType, BuildStatus, PrpCat
from VeraGridEngine.Devices.Parents.load_parent import LoadParent
from VeraGridEngine.Devices.Profiles import ProfileFloat, ProfileInt
from VeraGridEngine.Utils.Symbolic.block import VarPowerFlowReferenceType
from VeraGridEngine.Devices.Parents.editable_device import get_at, GCProp
[docs]
class Load(LoadParent):
"""
Load
"""
__slots__ = (
'_G',
'_B',
'_Ir',
'_Ii',
'_G_prof',
'_B_prof',
'_Ir_prof',
'_Ii_prof',
'_G1',
'_B1',
'_Ir1',
'_Ii1',
'_G1_prof',
'_B1_prof',
'_Ir1_prof',
'_Ii1_prof',
'_G2',
'_B2',
'_Ir2',
'_Ii2',
'_G2_prof',
'_B2_prof',
'_Ir2_prof',
'_Ii2_prof',
'_G3',
'_B3',
'_Ir3',
'_Ii3',
'_G3_prof',
'_B3_prof',
'_Ir3_prof',
'_Ii3_prof',
'_contract_power',
'_n_customers',
'_n_customers_prof',
)
LOCAL_PROPERTY_DECLARATIONS: Tuple[GCProp, ...] = (
GCProp(
prop_name='Ir',
units='MW',
tpe=float,
definition='Active power of the current component at V=1.0 p.u.',
profile_name='Ir_prof',
cat=[PrpCat.PF],
),
GCProp(
prop_name='Ir1',
units='MW',
tpe=float,
definition='Active power of the phase 1 current component at V=1.0 p.u.',
profile_name='Ir1_prof',
cat=[PrpCat.PF3],
),
GCProp(
prop_name='Ir2',
units='MW',
tpe=float,
definition='Active power of the phase 2 current component at V=1.0 p.u.',
profile_name='Ir2_prof',
cat=[PrpCat.PF3],
),
GCProp(
prop_name='Ir3',
units='MW',
tpe=float,
definition='Active power of the phase 3 current component at V=1.0 p.u.',
profile_name='Ir3_prof',
cat=[PrpCat.PF3],
),
GCProp(
prop_name='Ii',
units='MVAr',
tpe=float,
definition='Reactive power of the current component at V=1.0 p.u.',
profile_name='Ii_prof',
cat=[PrpCat.PF],
),
GCProp(
prop_name='Ii1',
units='MVAr',
tpe=float,
definition='Reactive power of the phase 1 current component at V=1.0 p.u.',
profile_name='Ii1_prof',
cat=[PrpCat.PF3],
),
GCProp(
prop_name='Ii2',
units='MVAr',
tpe=float,
definition='Reactive power of the phase 2 current component at V=1.0 p.u.',
profile_name='Ii2_prof',
cat=[PrpCat.PF3],
),
GCProp(
prop_name='Ii3',
units='MVAr',
tpe=float,
definition='Reactive power of the phase 3 current component at V=1.0 p.u.',
profile_name='Ii3_prof',
cat=[PrpCat.PF3],
),
GCProp(
prop_name='G',
units='MW',
tpe=float,
definition='Active power of the impedance component at V=1.0 p.u.',
profile_name='G_prof',
cat=[PrpCat.PF],
),
GCProp(
prop_name='G1',
units='MW',
tpe=float,
definition='Active power of the phase 1 impedance component at V=1.0 p.u.',
profile_name='G1_prof',
cat=[PrpCat.PF3],
),
GCProp(
prop_name='G2',
units='MW',
tpe=float,
definition='Active power of the phase 2 impedance component at V=1.0 p.u.',
profile_name='G2_prof',
cat=[PrpCat.PF3],
),
GCProp(
prop_name='G3',
units='MW',
tpe=float,
definition='Active power of the phase 3 impedance component at V=1.0 p.u.',
profile_name='G3_prof',
cat=[PrpCat.PF3],
),
GCProp(
prop_name='B',
units='MVAr',
tpe=float,
definition='Reactive power of the impedance component at V=1.0 p.u.',
profile_name='B_prof',
cat=[PrpCat.PF],
),
GCProp(
prop_name='B1',
units='MVAr',
tpe=float,
definition='Reactive power of the phase 1 impedance component at V=1.0 p.u.',
profile_name='B1_prof',
cat=[PrpCat.PF3],
),
GCProp(
prop_name='B2',
units='MVAr',
tpe=float,
definition='Reactive power of the phase 2 impedance component at V=1.0 p.u.',
profile_name='B2_prof',
cat=[PrpCat.PF3],
),
GCProp(
prop_name='B3',
units='MVAr',
tpe=float,
definition='Reactive power of the phase 3 impedance component at V=1.0 p.u.',
profile_name='B3_prof',
cat=[PrpCat.PF3],
),
GCProp(
prop_name='n_customers',
units='unit',
tpe=int,
definition='Number of customers represented by this load',
profile_name='n_customers_prof',
cat=[PrpCat.REL],
),
GCProp(
prop_name='contract_power',
units='MW',
tpe=float,
definition='Nominal contracted power',
cat=[PrpCat.REL],
),
)
def __init__(self, name='Load', idtag=None, code='',
G=0.0, B=0.0, Ir=0.0, Ii=0.0, P=0.0, Q=0.0, Cost=1200.0,
P1=0.0, P2=0.0, P3=0.0, Q1=0.0, Q2=0.0, Q3=0.0,
G1=0.0, G2=0.0, G3=0.0, B1=0.0, B2=0.0, B3=0.0,
Ir1=0.0, Ir2=0.0, Ir3=0.0, Ii1=0.0, Ii2=0.0, Ii3=0.0,
active=True, mttf=0.0, mttr=0.0, capex=0, opex=0,
n_customers: int = 0,
contracted_power: float = 0.0,
build_status: BuildStatus = BuildStatus.Commissioned):
"""
The load object implements the so-called ZIP model, in which the load can be
represented by a combination of power (P), current(I), and impedance (Z).
The sign convention is: Positive to act as a load, negative to act as a generator.
:param name: Name of the load
:param idtag: UUID code
:param code: secondary ID code
:param G: Conductance in equivalent MW
:param G1: Conductance in equivalent MW
:param G2: Conductance in equivalent MW
:param G3: Conductance in equivalent MW
:param B: Susceptance in equivalent MVAr
:param B1: Susceptance in equivalent MVAr
:param B2: Susceptance in equivalent MVAr
:param B3: Susceptance in equivalent MVAr
:param Ir: Real current in equivalent MW
:param Ir1: Real current in equivalent MW
:param Ir2: Real current in equivalent MW
:param Ir3: Real current in equivalent MW
:param Ii: Imaginary current in equivalent MVAr
:param Ii1: Imaginary current in equivalent MVAr
:param Ii2: Imaginary current in equivalent MVAr
:param Ii3: Imaginary current in equivalent MVAr
:param P: Active power in MW
:param P1: Active power in MW
:param P2: Active power in MW
:param P3: Active power in MW
:param Q: Reactive power in MVAr
:param Q1: Reactive power in MVAr
:param Q2: Reactive power in MVAr
:param Q3: Reactive power in MVAr
:param Cost: Cost of load shedding
:param active: Is the load active?
:param mttf: Mean time to failure in hours
:param mttr: Mean time to recovery in hours
"""
LoadParent.__init__(self,
name=name,
idtag=idtag,
code=code,
bus=None,
active=active,
P=P,
P1=P1,
P2=P2,
P3=P3,
Q=Q,
Q1=Q1,
Q2=Q2,
Q3=Q3,
Cost=Cost,
mttf=mttf,
mttr=mttr,
capex=capex,
opex=opex,
build_status=build_status,
device_type=DeviceType.LoadDevice)
self.G = float(G)
self.G1 = float(G1)
self.G2 = float(G2)
self.G3 = float(G3)
self.B = float(B)
self.B1 = float(B1)
self.B2 = float(B2)
self.B3 = float(B3)
self.Ir = float(Ir)
self.Ir1 = float(Ir1)
self.Ir2 = float(Ir2)
self.Ir3 = float(Ir3)
self.Ii = float(Ii)
self.Ii1 = float(Ii1)
self.Ii2 = float(Ii2)
self.Ii3 = float(Ii3)
self._G_prof = ProfileFloat(default_value=self.G)
self._G1_prof = ProfileFloat(default_value=self.G1)
self._G2_prof = ProfileFloat(default_value=self.G2)
self._G3_prof = ProfileFloat(default_value=self.G3)
self._B_prof = ProfileFloat(default_value=self.B)
self._B1_prof = ProfileFloat(default_value=self.B1)
self._B2_prof = ProfileFloat(default_value=self.B2)
self._B3_prof = ProfileFloat(default_value=self.B3)
self._Ir_prof = ProfileFloat(default_value=self.Ir)
self._Ir1_prof = ProfileFloat(default_value=self.Ir1)
self._Ir2_prof = ProfileFloat(default_value=self.Ir2)
self._Ir3_prof = ProfileFloat(default_value=self.Ir3)
self._Ii_prof = ProfileFloat(default_value=self.Ii)
self._Ii1_prof = ProfileFloat(default_value=self.Ii1)
self._Ii2_prof = ProfileFloat(default_value=self.Ii2)
self._Ii3_prof = ProfileFloat(default_value=self.Ii3)
self._n_customers: int = n_customers
self._n_customers_prof = ProfileInt(default_value=self._n_customers)
self._contract_power: float = contracted_power
@property
def Ir_prof(self) -> ProfileFloat:
"""
Cost profile
:return: Profile
"""
return self._Ir_prof
@Ir_prof.setter
def Ir_prof(self, val: Union[ProfileFloat, np.ndarray]):
if isinstance(val, ProfileFloat):
self._Ir_prof = val
elif isinstance(val, np.ndarray):
self._Ir_prof.set(arr=val)
else:
raise Exception(str(type(val)) + 'not supported to be set into a Ir_prof')
[docs]
def get_Ir_at(self, t: int | None) -> float:
"""
:param t:
:return:
"""
return get_at(self.Ir, self.Ir_prof, t)
@property
def Ir1_prof(self) -> ProfileFloat:
"""
Cost profile
:return: Profile
"""
return self._Ir1_prof
@Ir1_prof.setter
def Ir1_prof(self, val: Union[ProfileFloat, np.ndarray]):
if isinstance(val, ProfileFloat):
self._Ir1_prof = val
elif isinstance(val, np.ndarray):
self._Ir1_prof.set(arr=val)
else:
raise Exception(str(type(val)) + 'not supported to be set into a Ir1_prof')
[docs]
def get_Ir1_at(self, t: int | None) -> float:
"""
:param t:
:return:
"""
return get_at(self.Ir1, self.Ir1_prof, t)
@property
def Ir2_prof(self) -> ProfileFloat:
"""
Cost profile
:return: Profile
"""
return self._Ir2_prof
@Ir2_prof.setter
def Ir2_prof(self, val: Union[ProfileFloat, np.ndarray]):
if isinstance(val, ProfileFloat):
self._Ir2_prof = val
elif isinstance(val, np.ndarray):
self._Ir2_prof.set(arr=val)
else:
raise Exception(str(type(val)) + 'not supported to be set into a Ir2_prof')
[docs]
def get_Ir2_at(self, t: int | None) -> float:
"""
:param t:
:return:
"""
return get_at(self.Ir2, self.Ir2_prof, t)
@property
def Ir3_prof(self) -> ProfileFloat:
"""
Cost profile
:return: Profile
"""
return self._Ir3_prof
@Ir3_prof.setter
def Ir3_prof(self, val: Union[ProfileFloat, np.ndarray]):
if isinstance(val, ProfileFloat):
self._Ir3_prof = val
elif isinstance(val, np.ndarray):
self._Ir3_prof.set(arr=val)
else:
raise Exception(str(type(val)) + 'not supported to be set into a Ir3_prof')
[docs]
def get_Ir3_at(self, t: int | None) -> float:
"""
:param t:
:return:
"""
return get_at(self.Ir3, self.Ir3_prof, t)
@property
def Ii_prof(self) -> ProfileFloat:
"""
Cost profile
:return: Profile
"""
return self._Ii_prof
@Ii_prof.setter
def Ii_prof(self, val: Union[ProfileFloat, np.ndarray]):
if isinstance(val, ProfileFloat):
self._Ii_prof = val
elif isinstance(val, np.ndarray):
self._Ii_prof.set(arr=val)
else:
raise Exception(str(type(val)) + 'not supported to be set into a Ii_prof')
[docs]
def get_Ii_at(self, t: int | None) -> float:
"""
:param t:
:return:
"""
return get_at(self.Ii, self.Ii_prof, t)
@property
def Ii1_prof(self) -> ProfileFloat:
"""
Cost profile
:return: Profile
"""
return self._Ii1_prof
@Ii1_prof.setter
def Ii1_prof(self, val: Union[ProfileFloat, np.ndarray]):
if isinstance(val, ProfileFloat):
self._Ii1_prof = val
elif isinstance(val, np.ndarray):
self._Ii1_prof.set(arr=val)
else:
raise Exception(str(type(val)) + 'not supported to be set into a Ii1_prof')
[docs]
def get_Ii1_at(self, t: int | None) -> float:
"""
:param t:
:return:
"""
return get_at(self.Ii1, self.Ii1_prof, t)
@property
def Ii2_prof(self) -> ProfileFloat:
"""
Cost profile
:return: Profile
"""
return self._Ii2_prof
@Ii2_prof.setter
def Ii2_prof(self, val: Union[ProfileFloat, np.ndarray]):
if isinstance(val, ProfileFloat):
self._Ii2_prof = val
elif isinstance(val, np.ndarray):
self._Ii2_prof.set(arr=val)
else:
raise Exception(str(type(val)) + 'not supported to be set into a Ii2_prof')
[docs]
def get_Ii2_at(self, t: int | None) -> float:
"""
:param t:
:return:
"""
return get_at(self.Ii2, self.Ii2_prof, t)
@property
def Ii3_prof(self) -> ProfileFloat:
"""
Cost profile
:return: Profile
"""
return self._Ii3_prof
@Ii3_prof.setter
def Ii3_prof(self, val: Union[ProfileFloat, np.ndarray]):
if isinstance(val, ProfileFloat):
self._Ii3_prof = val
elif isinstance(val, np.ndarray):
self._Ii3_prof.set(arr=val)
else:
raise Exception(str(type(val)) + 'not supported to be set into a Ii3_prof')
[docs]
def get_Ii3_at(self, t: int | None) -> float:
"""
:param t:
:return:
"""
return get_at(self.Ii3, self.Ii3_prof, t)
@property
def G_prof(self) -> ProfileFloat:
"""
Cost profile
:return: Profile
"""
return self._G_prof
@G_prof.setter
def G_prof(self, val: Union[ProfileFloat, np.ndarray]):
if isinstance(val, ProfileFloat):
self._G_prof = val
elif isinstance(val, np.ndarray):
self._G_prof.set(arr=val)
else:
raise Exception(str(type(val)) + 'not supported to be set into a G_prof')
[docs]
def get_G_at(self, t: int | None) -> float:
"""
:param t:
:return:
"""
return get_at(self.G, self.G_prof, t)
@property
def G1_prof(self) -> ProfileFloat:
"""
Cost profile
:return: Profile
"""
return self._G1_prof
@G1_prof.setter
def G1_prof(self, val: Union[ProfileFloat, np.ndarray]):
if isinstance(val, ProfileFloat):
self._G1_prof = val
elif isinstance(val, np.ndarray):
self._G1_prof.set(arr=val)
else:
raise Exception(str(type(val)) + 'not supported to be set into a G1_prof')
[docs]
def get_G1_at(self, t: int | None) -> float:
"""
:param t:
:return:
"""
return get_at(self.G1, self.G1_prof, t)
@property
def G2_prof(self) -> ProfileFloat:
"""
Cost profile
:return: Profile
"""
return self._G2_prof
@G2_prof.setter
def G2_prof(self, val: Union[ProfileFloat, np.ndarray]):
if isinstance(val, ProfileFloat):
self._G2_prof = val
elif isinstance(val, np.ndarray):
self._G2_prof.set(arr=val)
else:
raise Exception(str(type(val)) + 'not supported to be set into a G2_prof')
[docs]
def get_G2_at(self, t: int | None) -> float:
"""
:param t:
:return:
"""
return get_at(self.G2, self.G2_prof, t)
@property
def G3_prof(self) -> ProfileFloat:
"""
Cost profile
:return: Profile
"""
return self._G3_prof
@G3_prof.setter
def G3_prof(self, val: Union[ProfileFloat, np.ndarray]):
if isinstance(val, ProfileFloat):
self._G3_prof = val
elif isinstance(val, np.ndarray):
self._G3_prof.set(arr=val)
else:
raise Exception(str(type(val)) + 'not supported to be set into a G3_prof')
[docs]
def get_G3_at(self, t: int | None) -> float:
"""
:param t:
:return:
"""
return get_at(self.G3, self.G3_prof, t)
@property
def B_prof(self) -> ProfileFloat:
"""
Cost profile
:return: Profile
"""
return self._B_prof
@B_prof.setter
def B_prof(self, val: Union[ProfileFloat, np.ndarray]):
if isinstance(val, ProfileFloat):
self._B_prof = val
elif isinstance(val, np.ndarray):
self._B_prof.set(arr=val)
else:
raise Exception(str(type(val)) + 'not supported to be set into a B_prof')
[docs]
def get_B_at(self, t: int | None) -> float:
"""
:param t:
:return:
"""
return get_at(self.B, self.B_prof, t)
@property
def B1_prof(self) -> ProfileFloat:
"""
Cost profile
:return: Profile
"""
return self._B1_prof
@B1_prof.setter
def B1_prof(self, val: Union[ProfileFloat, np.ndarray]):
if isinstance(val, ProfileFloat):
self._B1_prof = val
elif isinstance(val, np.ndarray):
self._B1_prof.set(arr=val)
else:
raise Exception(str(type(val)) + 'not supported to be set into a B1_prof')
[docs]
def get_B1_at(self, t: int | None) -> float:
"""
:param t:
:return:
"""
return get_at(self.B1, self.B1_prof, t)
@property
def B2_prof(self) -> ProfileFloat:
"""
Cost profile
:return: Profile
"""
return self._B2_prof
@B2_prof.setter
def B2_prof(self, val: Union[ProfileFloat, np.ndarray]):
if isinstance(val, ProfileFloat):
self._B2_prof = val
elif isinstance(val, np.ndarray):
self._B2_prof.set(arr=val)
else:
raise Exception(str(type(val)) + 'not supported to be set into a B2_prof')
[docs]
def get_B2_at(self, t: int | None) -> float:
"""
:param t:
:return:
"""
return get_at(self.B2, self.B2_prof, t)
@property
def B3_prof(self) -> ProfileFloat:
"""
Cost profile
:return: Profile
"""
return self._B3_prof
@B3_prof.setter
def B3_prof(self, val: Union[ProfileFloat, np.ndarray]):
if isinstance(val, ProfileFloat):
self._B3_prof = val
elif isinstance(val, np.ndarray):
self._B3_prof.set(arr=val)
else:
raise Exception(str(type(val)) + 'not supported to be set into a B3_prof')
[docs]
def get_B3_at(self, t: int | None) -> float:
"""
:param t:
:return:
"""
return get_at(self.B3, self.B3_prof, t)
[docs]
def get_I_at(self, t: int | None) -> complex:
"""
:param t:
:return:
"""
return complex(self.get_Ir_at(t), self.get_Ii_at(t))
[docs]
def get_I1_at(self, t: int | None) -> complex:
"""
:param t:
:return:
"""
return complex(self.get_Ir1_at(t), self.get_Ii1_at(t))
[docs]
def get_I2_at(self, t: int | None) -> complex:
"""
:param t:
:return:
"""
return complex(self.get_Ir2_at(t), self.get_Ii2_at(t))
[docs]
def get_I3_at(self, t: int | None) -> complex:
"""
:param t:
:return:
"""
return complex(self.get_Ir3_at(t), self.get_Ii3_at(t))
[docs]
def get_Y_at(self, t: int | None) -> complex:
"""
:param t:
:return:
"""
return complex(self.get_G_at(t), self.get_B_at(t))
[docs]
def get_Y1_at(self, t: int | None) -> complex:
"""
:param t:
:return:
"""
return complex(self.get_G1_at(t), self.get_B1_at(t))
[docs]
def get_Y2_at(self, t: int | None) -> complex:
"""
:param t:
:return:
"""
return complex(self.get_G2_at(t), self.get_B2_at(t))
[docs]
def get_Y3_at(self, t: int | None) -> complex:
"""
:param t:
:return:
"""
return complex(self.get_G3_at(t), self.get_B3_at(t))
[docs]
def get_Y_conj_at(self, t: int | None) -> complex:
"""
:param t:
:return:
"""
return complex(self.get_G_at(t), -self.get_B_at(t))
[docs]
def get_Y1_conj_at(self, t: int | None) -> complex:
"""
:param t:
:return:
"""
return complex(self.get_G1_at(t), -self.get_B1_at(t))
[docs]
def get_Y2_conj_at(self, t: int | None) -> complex:
"""
:param t:
:return:
"""
return complex(self.get_G2_at(t), -self.get_B2_at(t))
[docs]
def get_Y3_conj_at(self, t: int | None) -> complex:
"""
:param t:
:return:
"""
return complex(self.get_G3_at(t), -self.get_B3_at(t))
@property
def n_customers(self) -> int:
"""
Return the number of customers
"""
return self._n_customers
@n_customers.setter
def n_customers(self, val: int):
"""
Set the number of customers
:param val: value greater than 0
"""
val = int(val)
try:
val2 = int(val)
if val2 > 0:
self._n_customers = val2
else:
pass
except ValueError as e:
print(e)
@property
def contract_power(self) -> float:
"""
Return the contracted power
"""
return self._contract_power
@contract_power.setter
def contract_power(self, val: float):
"""
Set the contracted power
:param val: value greater than 0
"""
val = float(val)
try:
val2 = float(val)
if val2 > 0:
self._contract_power = val2
else:
pass
except ValueError as e:
print(e)
@property
def n_customers_prof(self) -> ProfileInt:
"""
Cost profile
:return: Profile
"""
return self._n_customers_prof
@n_customers_prof.setter
def n_customers_prof(self, val: Union[ProfileInt, np.ndarray]):
if isinstance(val, ProfileInt):
self._n_customers_prof = val
elif isinstance(val, np.ndarray):
self._n_customers_prof.set(arr=val)
else:
raise Exception(str(type(val)) + 'not supported to be set into n_customers_prof')
[docs]
def plot_profiles(self, time=None, show_fig=True):
"""
Plot the time series results of this object
:param time: array of time values
:param show_fig: Show the figure?
"""
if time is not None:
fig = plt.figure(figsize=(12, 8))
ax_1 = fig.add_subplot(211)
ax_2 = fig.add_subplot(212, sharex=ax_1)
# P
y = self.P_prof.toarray()
df = pd.DataFrame(data=y, index=time, columns=[self.name])
ax_1.set_title('Active power', fontsize=14)
ax_1.set_ylabel('MW', fontsize=11)
df.plot(ax=ax_1)
# Q
y = self.Q_prof.toarray()
df = pd.DataFrame(data=y, index=time, columns=[self.name])
ax_2.set_title('Reactive power', fontsize=14)
ax_2.set_ylabel('MVAr', fontsize=11)
df.plot(ax=ax_2)
plt.legend()
fig.suptitle(self.name, fontsize=20)
if show_fig:
plt.show()
[docs]
def initialize_rms(self, rms_event=False):
"""
:param rms_event:
:return:
"""
if self._rms_model.empty():
load_template = get_load_rms_template()
self.rms_model = load_template.block
# Scalar property accessors coerce assignments to the declared schema types.
@property
def Ir(self) -> float:
"""
Get ``Ir``.
:return: float
"""
return self._Ir
@Ir.setter
def Ir(self, val: float) -> None:
"""
Set ``Ir``.
:param val: Value to assign.
:return: None
"""
self._Ir = float(val)
@property
def Ir1(self) -> float:
"""
Get ``Ir1``.
:return: float
"""
return self._Ir1
@Ir1.setter
def Ir1(self, val: float) -> None:
"""
Set ``Ir1``.
:param val: Value to assign.
:return: None
"""
self._Ir1 = float(val)
@property
def Ir2(self) -> float:
"""
Get ``Ir2``.
:return: float
"""
return self._Ir2
@Ir2.setter
def Ir2(self, val: float) -> None:
"""
Set ``Ir2``.
:param val: Value to assign.
:return: None
"""
self._Ir2 = float(val)
@property
def Ir3(self) -> float:
"""
Get ``Ir3``.
:return: float
"""
return self._Ir3
@Ir3.setter
def Ir3(self, val: float) -> None:
"""
Set ``Ir3``.
:param val: Value to assign.
:return: None
"""
self._Ir3 = float(val)
@property
def Ii(self) -> float:
"""
Get ``Ii``.
:return: float
"""
return self._Ii
@Ii.setter
def Ii(self, val: float) -> None:
"""
Set ``Ii``.
:param val: Value to assign.
:return: None
"""
self._Ii = float(val)
@property
def Ii1(self) -> float:
"""
Get ``Ii1``.
:return: float
"""
return self._Ii1
@Ii1.setter
def Ii1(self, val: float) -> None:
"""
Set ``Ii1``.
:param val: Value to assign.
:return: None
"""
self._Ii1 = float(val)
@property
def Ii2(self) -> float:
"""
Get ``Ii2``.
:return: float
"""
return self._Ii2
@Ii2.setter
def Ii2(self, val: float) -> None:
"""
Set ``Ii2``.
:param val: Value to assign.
:return: None
"""
self._Ii2 = float(val)
@property
def Ii3(self) -> float:
"""
Get ``Ii3``.
:return: float
"""
return self._Ii3
@Ii3.setter
def Ii3(self, val: float) -> None:
"""
Set ``Ii3``.
:param val: Value to assign.
:return: None
"""
self._Ii3 = float(val)
@property
def G(self) -> float:
"""
Get ``G``.
:return: float
"""
return self._G
@G.setter
def G(self, val: float) -> None:
"""
Set ``G``.
:param val: Value to assign.
:return: None
"""
self._G = float(val)
@property
def G1(self) -> float:
"""
Get ``G1``.
:return: float
"""
return self._G1
@G1.setter
def G1(self, val: float) -> None:
"""
Set ``G1``.
:param val: Value to assign.
:return: None
"""
self._G1 = float(val)
@property
def G2(self) -> float:
"""
Get ``G2``.
:return: float
"""
return self._G2
@G2.setter
def G2(self, val: float) -> None:
"""
Set ``G2``.
:param val: Value to assign.
:return: None
"""
self._G2 = float(val)
@property
def G3(self) -> float:
"""
Get ``G3``.
:return: float
"""
return self._G3
@G3.setter
def G3(self, val: float) -> None:
"""
Set ``G3``.
:param val: Value to assign.
:return: None
"""
self._G3 = float(val)
@property
def B(self) -> float:
"""
Get ``B``.
:return: float
"""
return self._B
@B.setter
def B(self, val: float) -> None:
"""
Set ``B``.
:param val: Value to assign.
:return: None
"""
self._B = float(val)
@property
def B1(self) -> float:
"""
Get ``B1``.
:return: float
"""
return self._B1
@B1.setter
def B1(self, val: float) -> None:
"""
Set ``B1``.
:param val: Value to assign.
:return: None
"""
self._B1 = float(val)
@property
def B2(self) -> float:
"""
Get ``B2``.
:return: float
"""
return self._B2
@B2.setter
def B2(self, val: float) -> None:
"""
Set ``B2``.
:param val: Value to assign.
:return: None
"""
self._B2 = float(val)
@property
def B3(self) -> float:
"""
Get ``B3``.
:return: float
"""
return self._B3
@B3.setter
def B3(self, val: float) -> None:
"""
Set ``B3``.
:param val: Value to assign.
:return: None
"""
self._B3 = float(val)