Source code for pyleecan.Classes.EEC_SCIM

# -*- coding: utf-8 -*-
# File generated according to Generator/ClassesRef/Simulation/EEC_SCIM.csv
# WARNING! All changes made in this file will be lost!
"""Method code available at https://github.com/Eomys/pyleecan/tree/master/pyleecan/Methods/Simulation/EEC_SCIM
"""

from os import linesep
from sys import getsizeof
from logging import getLogger
from ._check import set_array, check_var, raise_
from ..Functions.get_logger import get_logger
from ..Functions.save import save
from ..Functions.load import load_init_dict
from ..Functions.Load.import_class import import_class
from copy import deepcopy
from .EEC import EEC

# Import all class method
# Try/catch to remove unnecessary dependencies in unused method
try:
    from ..Methods.Simulation.EEC_SCIM._comp_flux_mean import _comp_flux_mean
except ImportError as error:
    _comp_flux_mean = error

try:
    from ..Methods.Simulation.EEC_SCIM._comp_Lm_FEA import _comp_Lm_FEA
except ImportError as error:
    _comp_Lm_FEA = error

try:
    from ..Methods.Simulation.EEC_SCIM.clear_parameters import clear_parameters
except ImportError as error:
    clear_parameters = error

try:
    from ..Methods.Simulation.EEC_SCIM.comp_joule_losses import comp_joule_losses
except ImportError as error:
    comp_joule_losses = error

try:
    from ..Methods.Simulation.EEC_SCIM.comp_K21 import comp_K21
except ImportError as error:
    comp_K21 = error

try:
    from ..Methods.Simulation.EEC_SCIM.comp_L1 import comp_L1
except ImportError as error:
    comp_L1 = error

try:
    from ..Methods.Simulation.EEC_SCIM.comp_L2 import comp_L2
except ImportError as error:
    comp_L2 = error

try:
    from ..Methods.Simulation.EEC_SCIM.comp_parameters import comp_parameters
except ImportError as error:
    comp_parameters = error

try:
    from ..Methods.Simulation.EEC_SCIM.comp_R2 import comp_R2
except ImportError as error:
    comp_R2 = error

try:
    from ..Methods.Simulation.EEC_SCIM.comp_skin_effect import comp_skin_effect
except ImportError as error:
    comp_skin_effect = error

try:
    from ..Methods.Simulation.EEC_SCIM.solve import solve
except ImportError as error:
    solve = error

try:
    from ..Methods.Simulation.EEC_SCIM.solve_elementary import solve_elementary
except ImportError as error:
    solve_elementary = error

try:
    from ..Methods.Simulation.EEC_SCIM.update_from_ref import update_from_ref
except ImportError as error:
    update_from_ref = error


from numpy import array, array_equal
from numpy import isnan
from ._check import InitUnKnowClassError


[docs]class EEC_SCIM(EEC): """Electric module: Electrical Equivalent Circuit for Squirrel Cage Induction Machine""" VERSION = 1 # Check ImportError to remove unnecessary dependencies in unused method # cf Methods.Simulation.EEC_SCIM._comp_flux_mean if isinstance(_comp_flux_mean, ImportError): _comp_flux_mean = property( fget=lambda x: raise_( ImportError( "Can't use EEC_SCIM method _comp_flux_mean: " + str(_comp_flux_mean) ) ) ) else: _comp_flux_mean = _comp_flux_mean # cf Methods.Simulation.EEC_SCIM._comp_Lm_FEA if isinstance(_comp_Lm_FEA, ImportError): _comp_Lm_FEA = property( fget=lambda x: raise_( ImportError( "Can't use EEC_SCIM method _comp_Lm_FEA: " + str(_comp_Lm_FEA) ) ) ) else: _comp_Lm_FEA = _comp_Lm_FEA # cf Methods.Simulation.EEC_SCIM.clear_parameters if isinstance(clear_parameters, ImportError): clear_parameters = property( fget=lambda x: raise_( ImportError( "Can't use EEC_SCIM method clear_parameters: " + str(clear_parameters) ) ) ) else: clear_parameters = clear_parameters # cf Methods.Simulation.EEC_SCIM.comp_joule_losses if isinstance(comp_joule_losses, ImportError): comp_joule_losses = property( fget=lambda x: raise_( ImportError( "Can't use EEC_SCIM method comp_joule_losses: " + str(comp_joule_losses) ) ) ) else: comp_joule_losses = comp_joule_losses # cf Methods.Simulation.EEC_SCIM.comp_K21 if isinstance(comp_K21, ImportError): comp_K21 = property( fget=lambda x: raise_( ImportError("Can't use EEC_SCIM method comp_K21: " + str(comp_K21)) ) ) else: comp_K21 = comp_K21 # cf Methods.Simulation.EEC_SCIM.comp_L1 if isinstance(comp_L1, ImportError): comp_L1 = property( fget=lambda x: raise_( ImportError("Can't use EEC_SCIM method comp_L1: " + str(comp_L1)) ) ) else: comp_L1 = comp_L1 # cf Methods.Simulation.EEC_SCIM.comp_L2 if isinstance(comp_L2, ImportError): comp_L2 = property( fget=lambda x: raise_( ImportError("Can't use EEC_SCIM method comp_L2: " + str(comp_L2)) ) ) else: comp_L2 = comp_L2 # cf Methods.Simulation.EEC_SCIM.comp_parameters if isinstance(comp_parameters, ImportError): comp_parameters = property( fget=lambda x: raise_( ImportError( "Can't use EEC_SCIM method comp_parameters: " + str(comp_parameters) ) ) ) else: comp_parameters = comp_parameters # cf Methods.Simulation.EEC_SCIM.comp_R2 if isinstance(comp_R2, ImportError): comp_R2 = property( fget=lambda x: raise_( ImportError("Can't use EEC_SCIM method comp_R2: " + str(comp_R2)) ) ) else: comp_R2 = comp_R2 # cf Methods.Simulation.EEC_SCIM.comp_skin_effect if isinstance(comp_skin_effect, ImportError): comp_skin_effect = property( fget=lambda x: raise_( ImportError( "Can't use EEC_SCIM method comp_skin_effect: " + str(comp_skin_effect) ) ) ) else: comp_skin_effect = comp_skin_effect # cf Methods.Simulation.EEC_SCIM.solve if isinstance(solve, ImportError): solve = property( fget=lambda x: raise_( ImportError("Can't use EEC_SCIM method solve: " + str(solve)) ) ) else: solve = solve # cf Methods.Simulation.EEC_SCIM.solve_elementary if isinstance(solve_elementary, ImportError): solve_elementary = property( fget=lambda x: raise_( ImportError( "Can't use EEC_SCIM method solve_elementary: " + str(solve_elementary) ) ) ) else: solve_elementary = solve_elementary # cf Methods.Simulation.EEC_SCIM.update_from_ref if isinstance(update_from_ref, ImportError): update_from_ref = property( fget=lambda x: raise_( ImportError( "Can't use EEC_SCIM method update_from_ref: " + str(update_from_ref) ) ) ) else: update_from_ref = update_from_ref # generic save method is available in all object save = save # get_logger method is available in all object get_logger = get_logger def __init__( self, Rfe=None, L1=None, R2=None, L2=None, K21Z=None, K21I=None, Im_table=None, Lm_table=None, I1=None, I2=None, U1=None, U2=None, If=None, Lm=None, Im=None, type_skin_effect=1, OP=None, Tsta=20, Trot=20, Xkr_skinS=1, Xke_skinS=1, Xkr_skinR=1, Xke_skinR=1, R1=None, fluxlink=None, init_dict=None, init_str=None, ): """Constructor of the class. Can be use in three ways : - __init__ (arg1 = 1, arg3 = 5) every parameters have name and default values for pyleecan type, -1 will call the default constructor - __init__ (init_dict = d) d must be a dictionary with property names as keys - __init__ (init_str = s) s must be a string s is the file path to load ndarray or list can be given for Vector and Matrix object or dict can be given for pyleecan Object""" if init_str is not None: # Load from a file init_dict = load_init_dict(init_str)[1] if init_dict is not None: # Initialisation by dict assert type(init_dict) is dict # Overwrite default value with init_dict content if "Rfe" in list(init_dict.keys()): Rfe = init_dict["Rfe"] if "L1" in list(init_dict.keys()): L1 = init_dict["L1"] if "R2" in list(init_dict.keys()): R2 = init_dict["R2"] if "L2" in list(init_dict.keys()): L2 = init_dict["L2"] if "K21Z" in list(init_dict.keys()): K21Z = init_dict["K21Z"] if "K21I" in list(init_dict.keys()): K21I = init_dict["K21I"] if "Im_table" in list(init_dict.keys()): Im_table = init_dict["Im_table"] if "Lm_table" in list(init_dict.keys()): Lm_table = init_dict["Lm_table"] if "I1" in list(init_dict.keys()): I1 = init_dict["I1"] if "I2" in list(init_dict.keys()): I2 = init_dict["I2"] if "U1" in list(init_dict.keys()): U1 = init_dict["U1"] if "U2" in list(init_dict.keys()): U2 = init_dict["U2"] if "If" in list(init_dict.keys()): If = init_dict["If"] if "Lm" in list(init_dict.keys()): Lm = init_dict["Lm"] if "Im" in list(init_dict.keys()): Im = init_dict["Im"] if "type_skin_effect" in list(init_dict.keys()): type_skin_effect = init_dict["type_skin_effect"] if "OP" in list(init_dict.keys()): OP = init_dict["OP"] if "Tsta" in list(init_dict.keys()): Tsta = init_dict["Tsta"] if "Trot" in list(init_dict.keys()): Trot = init_dict["Trot"] if "Xkr_skinS" in list(init_dict.keys()): Xkr_skinS = init_dict["Xkr_skinS"] if "Xke_skinS" in list(init_dict.keys()): Xke_skinS = init_dict["Xke_skinS"] if "Xkr_skinR" in list(init_dict.keys()): Xkr_skinR = init_dict["Xkr_skinR"] if "Xke_skinR" in list(init_dict.keys()): Xke_skinR = init_dict["Xke_skinR"] if "R1" in list(init_dict.keys()): R1 = init_dict["R1"] if "fluxlink" in list(init_dict.keys()): fluxlink = init_dict["fluxlink"] # Set the properties (value check and convertion are done in setter) self.Rfe = Rfe self.L1 = L1 self.R2 = R2 self.L2 = L2 self.K21Z = K21Z self.K21I = K21I self.Im_table = Im_table self.Lm_table = Lm_table self.I1 = I1 self.I2 = I2 self.U1 = U1 self.U2 = U2 self.If = If self.Lm = Lm self.Im = Im # Call EEC init super(EEC_SCIM, self).__init__( type_skin_effect=type_skin_effect, OP=OP, Tsta=Tsta, Trot=Trot, Xkr_skinS=Xkr_skinS, Xke_skinS=Xke_skinS, Xkr_skinR=Xkr_skinR, Xke_skinR=Xke_skinR, R1=R1, fluxlink=fluxlink, ) # The class is frozen (in EEC init), for now it's impossible to # add new properties def __str__(self): """Convert this object in a readeable string (for print)""" EEC_SCIM_str = "" # Get the properties inherited from EEC EEC_SCIM_str += super(EEC_SCIM, self).__str__() EEC_SCIM_str += "Rfe = " + str(self.Rfe) + linesep EEC_SCIM_str += "L1 = " + str(self.L1) + linesep EEC_SCIM_str += "R2 = " + str(self.R2) + linesep EEC_SCIM_str += "L2 = " + str(self.L2) + linesep EEC_SCIM_str += "K21Z = " + str(self.K21Z) + linesep EEC_SCIM_str += "K21I = " + str(self.K21I) + linesep EEC_SCIM_str += ( "Im_table = " + linesep + str(self.Im_table).replace(linesep, linesep + "\t") + linesep + linesep ) EEC_SCIM_str += ( "Lm_table = " + linesep + str(self.Lm_table).replace(linesep, linesep + "\t") + linesep + linesep ) EEC_SCIM_str += "I1 = " + str(self.I1) + linesep EEC_SCIM_str += "I2 = " + str(self.I2) + linesep EEC_SCIM_str += "U1 = " + str(self.U1) + linesep EEC_SCIM_str += "U2 = " + str(self.U2) + linesep EEC_SCIM_str += "If = " + str(self.If) + linesep EEC_SCIM_str += "Lm = " + str(self.Lm) + linesep EEC_SCIM_str += "Im = " + str(self.Im) + linesep return EEC_SCIM_str def __eq__(self, other): """Compare two objects (skip parent)""" if type(other) != type(self): return False # Check the properties inherited from EEC if not super(EEC_SCIM, self).__eq__(other): return False if other.Rfe != self.Rfe: return False if other.L1 != self.L1: return False if other.R2 != self.R2: return False if other.L2 != self.L2: return False if other.K21Z != self.K21Z: return False if other.K21I != self.K21I: return False if not array_equal(other.Im_table, self.Im_table): return False if not array_equal(other.Lm_table, self.Lm_table): return False if other.I1 != self.I1: return False if other.I2 != self.I2: return False if other.U1 != self.U1: return False if other.U2 != self.U2: return False if other.If != self.If: return False if other.Lm != self.Lm: return False if other.Im != self.Im: return False return True
[docs] def compare(self, other, name="self", ignore_list=None, is_add_value=False): """Compare two objects and return list of differences""" if ignore_list is None: ignore_list = list() if type(other) != type(self): return ["type(" + name + ")"] diff_list = list() # Check the properties inherited from EEC diff_list.extend( super(EEC_SCIM, self).compare( other, name=name, ignore_list=ignore_list, is_add_value=is_add_value ) ) if ( other._Rfe is not None and self._Rfe is not None and isnan(other._Rfe) and isnan(self._Rfe) ): pass elif other._Rfe != self._Rfe: if is_add_value: val_str = ( " (self=" + str(self._Rfe) + ", other=" + str(other._Rfe) + ")" ) diff_list.append(name + ".Rfe" + val_str) else: diff_list.append(name + ".Rfe") if ( other._L1 is not None and self._L1 is not None and isnan(other._L1) and isnan(self._L1) ): pass elif other._L1 != self._L1: if is_add_value: val_str = " (self=" + str(self._L1) + ", other=" + str(other._L1) + ")" diff_list.append(name + ".L1" + val_str) else: diff_list.append(name + ".L1") if ( other._R2 is not None and self._R2 is not None and isnan(other._R2) and isnan(self._R2) ): pass elif other._R2 != self._R2: if is_add_value: val_str = " (self=" + str(self._R2) + ", other=" + str(other._R2) + ")" diff_list.append(name + ".R2" + val_str) else: diff_list.append(name + ".R2") if ( other._L2 is not None and self._L2 is not None and isnan(other._L2) and isnan(self._L2) ): pass elif other._L2 != self._L2: if is_add_value: val_str = " (self=" + str(self._L2) + ", other=" + str(other._L2) + ")" diff_list.append(name + ".L2" + val_str) else: diff_list.append(name + ".L2") if ( other._K21Z is not None and self._K21Z is not None and isnan(other._K21Z) and isnan(self._K21Z) ): pass elif other._K21Z != self._K21Z: if is_add_value: val_str = ( " (self=" + str(self._K21Z) + ", other=" + str(other._K21Z) + ")" ) diff_list.append(name + ".K21Z" + val_str) else: diff_list.append(name + ".K21Z") if ( other._K21I is not None and self._K21I is not None and isnan(other._K21I) and isnan(self._K21I) ): pass elif other._K21I != self._K21I: if is_add_value: val_str = ( " (self=" + str(self._K21I) + ", other=" + str(other._K21I) + ")" ) diff_list.append(name + ".K21I" + val_str) else: diff_list.append(name + ".K21I") if not array_equal(other.Im_table, self.Im_table): diff_list.append(name + ".Im_table") if not array_equal(other.Lm_table, self.Lm_table): diff_list.append(name + ".Lm_table") if other._I1 != self._I1: if is_add_value: val_str = " (self=" + str(self._I1) + ", other=" + str(other._I1) + ")" diff_list.append(name + ".I1" + val_str) else: diff_list.append(name + ".I1") if other._I2 != self._I2: if is_add_value: val_str = " (self=" + str(self._I2) + ", other=" + str(other._I2) + ")" diff_list.append(name + ".I2" + val_str) else: diff_list.append(name + ".I2") if other._U1 != self._U1: if is_add_value: val_str = " (self=" + str(self._U1) + ", other=" + str(other._U1) + ")" diff_list.append(name + ".U1" + val_str) else: diff_list.append(name + ".U1") if other._U2 != self._U2: if is_add_value: val_str = " (self=" + str(self._U2) + ", other=" + str(other._U2) + ")" diff_list.append(name + ".U2" + val_str) else: diff_list.append(name + ".U2") if other._If != self._If: if is_add_value: val_str = " (self=" + str(self._If) + ", other=" + str(other._If) + ")" diff_list.append(name + ".If" + val_str) else: diff_list.append(name + ".If") if ( other._Lm is not None and self._Lm is not None and isnan(other._Lm) and isnan(self._Lm) ): pass elif other._Lm != self._Lm: if is_add_value: val_str = " (self=" + str(self._Lm) + ", other=" + str(other._Lm) + ")" diff_list.append(name + ".Lm" + val_str) else: diff_list.append(name + ".Lm") if other._Im != self._Im: if is_add_value: val_str = " (self=" + str(self._Im) + ", other=" + str(other._Im) + ")" diff_list.append(name + ".Im" + val_str) else: diff_list.append(name + ".Im") # Filter ignore differences diff_list = list(filter(lambda x: x not in ignore_list, diff_list)) return diff_list
def __sizeof__(self): """Return the size in memory of the object (including all subobject)""" S = 0 # Full size of the object # Get size of the properties inherited from EEC S += super(EEC_SCIM, self).__sizeof__() S += getsizeof(self.Rfe) S += getsizeof(self.L1) S += getsizeof(self.R2) S += getsizeof(self.L2) S += getsizeof(self.K21Z) S += getsizeof(self.K21I) S += getsizeof(self.Im_table) S += getsizeof(self.Lm_table) S += getsizeof(self.I1) S += getsizeof(self.I2) S += getsizeof(self.U1) S += getsizeof(self.U2) S += getsizeof(self.If) S += getsizeof(self.Lm) S += getsizeof(self.Im) return S
[docs] def as_dict(self, type_handle_ndarray=0, keep_function=False, **kwargs): """ Convert this object in a json serializable dict (can be use in __init__). type_handle_ndarray: int How to handle ndarray (0: tolist, 1: copy, 2: nothing) keep_function : bool True to keep the function object, else return str Optional keyword input parameter is for internal use only and may prevent json serializability. """ # Get the properties inherited from EEC EEC_SCIM_dict = super(EEC_SCIM, self).as_dict( type_handle_ndarray=type_handle_ndarray, keep_function=keep_function, **kwargs ) EEC_SCIM_dict["Rfe"] = self.Rfe EEC_SCIM_dict["L1"] = self.L1 EEC_SCIM_dict["R2"] = self.R2 EEC_SCIM_dict["L2"] = self.L2 EEC_SCIM_dict["K21Z"] = self.K21Z EEC_SCIM_dict["K21I"] = self.K21I if self.Im_table is None: EEC_SCIM_dict["Im_table"] = None else: if type_handle_ndarray == 0: EEC_SCIM_dict["Im_table"] = self.Im_table.tolist() elif type_handle_ndarray == 1: EEC_SCIM_dict["Im_table"] = self.Im_table.copy() elif type_handle_ndarray == 2: EEC_SCIM_dict["Im_table"] = self.Im_table else: raise Exception( "Unknown type_handle_ndarray: " + str(type_handle_ndarray) ) if self.Lm_table is None: EEC_SCIM_dict["Lm_table"] = None else: if type_handle_ndarray == 0: EEC_SCIM_dict["Lm_table"] = self.Lm_table.tolist() elif type_handle_ndarray == 1: EEC_SCIM_dict["Lm_table"] = self.Lm_table.copy() elif type_handle_ndarray == 2: EEC_SCIM_dict["Lm_table"] = self.Lm_table else: raise Exception( "Unknown type_handle_ndarray: " + str(type_handle_ndarray) ) if self.I1 is None: EEC_SCIM_dict["I1"] = None elif isinstance(self.I1, float): EEC_SCIM_dict["I1"] = self.I1 else: EEC_SCIM_dict["I1"] = str(self.I1) if self.I2 is None: EEC_SCIM_dict["I2"] = None elif isinstance(self.I2, float): EEC_SCIM_dict["I2"] = self.I2 else: EEC_SCIM_dict["I2"] = str(self.I2) if self.U1 is None: EEC_SCIM_dict["U1"] = None elif isinstance(self.U1, float): EEC_SCIM_dict["U1"] = self.U1 else: EEC_SCIM_dict["U1"] = str(self.U1) if self.U2 is None: EEC_SCIM_dict["U2"] = None elif isinstance(self.U2, float): EEC_SCIM_dict["U2"] = self.U2 else: EEC_SCIM_dict["U2"] = str(self.U2) if self.If is None: EEC_SCIM_dict["If"] = None elif isinstance(self.If, float): EEC_SCIM_dict["If"] = self.If else: EEC_SCIM_dict["If"] = str(self.If) EEC_SCIM_dict["Lm"] = self.Lm if self.Im is None: EEC_SCIM_dict["Im"] = None elif isinstance(self.Im, float): EEC_SCIM_dict["Im"] = self.Im else: EEC_SCIM_dict["Im"] = str(self.Im) # The class name is added to the dict for deserialisation purpose # Overwrite the mother class name EEC_SCIM_dict["__class__"] = "EEC_SCIM" return EEC_SCIM_dict
[docs] def copy(self): """Creates a deepcopy of the object""" # Handle deepcopy of all the properties Rfe_val = self.Rfe L1_val = self.L1 R2_val = self.R2 L2_val = self.L2 K21Z_val = self.K21Z K21I_val = self.K21I if self.Im_table is None: Im_table_val = None else: Im_table_val = self.Im_table.copy() if self.Lm_table is None: Lm_table_val = None else: Lm_table_val = self.Lm_table.copy() I1_val = self.I1 I2_val = self.I2 U1_val = self.U1 U2_val = self.U2 If_val = self.If Lm_val = self.Lm Im_val = self.Im type_skin_effect_val = self.type_skin_effect if self.OP is None: OP_val = None else: OP_val = self.OP.copy() Tsta_val = self.Tsta Trot_val = self.Trot Xkr_skinS_val = self.Xkr_skinS Xke_skinS_val = self.Xke_skinS Xkr_skinR_val = self.Xkr_skinR Xke_skinR_val = self.Xke_skinR R1_val = self.R1 if self.fluxlink is None: fluxlink_val = None else: fluxlink_val = self.fluxlink.copy() # Creates new object of the same type with the copied properties obj_copy = type(self)( Rfe=Rfe_val, L1=L1_val, R2=R2_val, L2=L2_val, K21Z=K21Z_val, K21I=K21I_val, Im_table=Im_table_val, Lm_table=Lm_table_val, I1=I1_val, I2=I2_val, U1=U1_val, U2=U2_val, If=If_val, Lm=Lm_val, Im=Im_val, type_skin_effect=type_skin_effect_val, OP=OP_val, Tsta=Tsta_val, Trot=Trot_val, Xkr_skinS=Xkr_skinS_val, Xke_skinS=Xke_skinS_val, Xkr_skinR=Xkr_skinR_val, Xke_skinR=Xke_skinR_val, R1=R1_val, fluxlink=fluxlink_val, ) return obj_copy
def _set_None(self): """Set all the properties to None (except pyleecan object)""" self.Rfe = None self.L1 = None self.R2 = None self.L2 = None self.K21Z = None self.K21I = None self.Im_table = None self.Lm_table = None self.I1 = None self.I2 = None self.U1 = None self.U2 = None self.If = None self.Lm = None self.Im = None # Set to None the properties inherited from EEC super(EEC_SCIM, self)._set_None() def _get_Rfe(self): """getter of Rfe""" return self._Rfe def _set_Rfe(self, value): """setter of Rfe""" check_var("Rfe", value, "float") self._Rfe = value Rfe = property( fget=_get_Rfe, fset=_set_Rfe, doc=u"""Iron loss resistance :Type: float """, ) def _get_L1(self): """getter of L1""" return self._L1 def _set_L1(self, value): """setter of L1""" check_var("L1", value, "float") self._L1 = value L1 = property( fget=_get_L1, fset=_set_L1, doc=u"""Stator phase inductance :Type: float """, ) def _get_R2(self): """getter of R2""" return self._R2 def _set_R2(self, value): """setter of R2""" check_var("R2", value, "float") self._R2 = value R2 = property( fget=_get_R2, fset=_set_R2, doc=u"""Rotor phase resistance :Type: float """, ) def _get_L2(self): """getter of L2""" return self._L2 def _set_L2(self, value): """setter of L2""" check_var("L2", value, "float") self._L2 = value L2 = property( fget=_get_L2, fset=_set_L2, doc=u"""Rotor phase inductance :Type: float """, ) def _get_K21Z(self): """getter of K21Z""" return self._K21Z def _set_K21Z(self, value): """setter of K21Z""" check_var("K21Z", value, "float") self._K21Z = value K21Z = property( fget=_get_K21Z, fset=_set_K21Z, doc=u"""transformation ratio from secondary (2, rotor) to primary (1, stator) for impedance :Type: float """, ) def _get_K21I(self): """getter of K21I""" return self._K21I def _set_K21I(self, value): """setter of K21I""" check_var("K21I", value, "float") self._K21I = value K21I = property( fget=_get_K21I, fset=_set_K21I, doc=u"""transformation ratio from secondary (2, rotor) to primary (1, stator) for current :Type: float """, ) def _get_Im_table(self): """getter of Im_table""" return self._Im_table def _set_Im_table(self, value): """setter of Im_table""" if type(value) is int and value == -1: value = array([]) elif type(value) is list: try: value = array(value) except: pass check_var("Im_table", value, "ndarray") self._Im_table = value Im_table = property( fget=_get_Im_table, fset=_set_Im_table, doc=u"""Array of magnetizing current :Type: ndarray """, ) def _get_Lm_table(self): """getter of Lm_table""" return self._Lm_table def _set_Lm_table(self, value): """setter of Lm_table""" if type(value) is int and value == -1: value = array([]) elif type(value) is list: try: value = array(value) except: pass check_var("Lm_table", value, "ndarray") self._Lm_table = value Lm_table = property( fget=_get_Lm_table, fset=_set_Lm_table, doc=u"""Array of magnetizing inductance function of Im_table :Type: ndarray """, ) def _get_I1(self): """getter of I1""" return self._I1 def _set_I1(self, value): """setter of I1""" if isinstance(value, str): value = complex(value) check_var("I1", value, "complex") self._I1 = value I1 = property( fget=_get_I1, fset=_set_I1, doc=u"""Stator phase current (after solve) :Type: complex """, ) def _get_I2(self): """getter of I2""" return self._I2 def _set_I2(self, value): """setter of I2""" if isinstance(value, str): value = complex(value) check_var("I2", value, "complex") self._I2 = value I2 = property( fget=_get_I2, fset=_set_I2, doc=u"""Rotor phase current (after solve) :Type: complex """, ) def _get_U1(self): """getter of U1""" return self._U1 def _set_U1(self, value): """setter of U1""" if isinstance(value, str): value = complex(value) check_var("U1", value, "complex") self._U1 = value U1 = property( fget=_get_U1, fset=_set_U1, doc=u"""Stator phase voltage (after solve) :Type: complex """, ) def _get_U2(self): """getter of U2""" return self._U2 def _set_U2(self, value): """setter of U2""" if isinstance(value, str): value = complex(value) check_var("U2", value, "complex") self._U2 = value U2 = property( fget=_get_U2, fset=_set_U2, doc=u"""Rotor phase voltage (after solve) :Type: complex """, ) def _get_If(self): """getter of If""" return self._If def _set_If(self, value): """setter of If""" if isinstance(value, str): value = complex(value) check_var("If", value, "complex") self._If = value If = property( fget=_get_If, fset=_set_If, doc=u"""Iron loss current (after solve) :Type: complex """, ) def _get_Lm(self): """getter of Lm""" return self._Lm def _set_Lm(self, value): """setter of Lm""" check_var("Lm", value, "float") self._Lm = value Lm = property( fget=_get_Lm, fset=_set_Lm, doc=u"""Magnetizing inductance (after solve) :Type: float """, ) def _get_Im(self): """getter of Im""" return self._Im def _set_Im(self, value): """setter of Im""" if isinstance(value, str): value = complex(value) check_var("Im", value, "complex") self._Im = value Im = property( fget=_get_Im, fset=_set_Im, doc=u"""Magnetizing current (after solve) :Type: complex """, )