class Machine(FrozenClass): """Abstract class for machines""" VERSION = 1 # Check ImportError to remove unnecessary dependencies in unused method # cf Methods.Machine.Machine.build_geometry if isinstance(build_geometry, ImportError): build_geometry = property(fget=lambda x: raise_( ImportError("Can't use Machine method build_geometry: " + str( build_geometry)))) else: build_geometry = build_geometry # cf Methods.Machine.Machine.check if isinstance(check, ImportError): check = property(fget=lambda x: raise_( ImportError("Can't use Machine method check: " + str(check)))) else: check = check # cf Methods.Machine.Machine.comp_masses if isinstance(comp_masses, ImportError): comp_masses = property(fget=lambda x: raise_( ImportError("Can't use Machine method comp_masses: " + str( comp_masses)))) else: comp_masses = comp_masses # cf Methods.Machine.Machine.comp_width_airgap_mag if isinstance(comp_width_airgap_mag, ImportError): comp_width_airgap_mag = property(fget=lambda x: raise_( ImportError("Can't use Machine method comp_width_airgap_mag: " + str(comp_width_airgap_mag)))) else: comp_width_airgap_mag = comp_width_airgap_mag # cf Methods.Machine.Machine.comp_width_airgap_mec if isinstance(comp_width_airgap_mec, ImportError): comp_width_airgap_mec = property(fget=lambda x: raise_( ImportError("Can't use Machine method comp_width_airgap_mec: " + str(comp_width_airgap_mec)))) else: comp_width_airgap_mec = comp_width_airgap_mec # cf Methods.Machine.Machine.get_lamination if isinstance(get_lamination, ImportError): get_lamination = property(fget=lambda x: raise_( ImportError("Can't use Machine method get_lamination: " + str( get_lamination)))) else: get_lamination = get_lamination # cf Methods.Machine.Machine.comp_Rgap_mec if isinstance(comp_Rgap_mec, ImportError): comp_Rgap_mec = property(fget=lambda x: raise_( ImportError("Can't use Machine method comp_Rgap_mec: " + str( comp_Rgap_mec)))) else: comp_Rgap_mec = comp_Rgap_mec # cf Methods.Machine.Machine.plot if isinstance(plot, ImportError): plot = property(fget=lambda x: raise_( ImportError("Can't use Machine method plot: " + str(plot)))) else: plot = plot # cf Methods.Machine.Machine.comp_output_geo if isinstance(comp_output_geo, ImportError): comp_output_geo = property(fget=lambda x: raise_( ImportError("Can't use Machine method comp_output_geo: " + str( comp_output_geo)))) else: comp_output_geo = comp_output_geo # cf Methods.Machine.Machine.comp_length_airgap_active if isinstance(comp_length_airgap_active, ImportError): comp_length_airgap_active = property(fget=lambda x: raise_( ImportError("Can't use Machine method comp_length_airgap_active: " + str(comp_length_airgap_active)))) else: comp_length_airgap_active = comp_length_airgap_active # cf Methods.Machine.Machine.get_polar_eq if isinstance(get_polar_eq, ImportError): get_polar_eq = property(fget=lambda x: raise_( ImportError("Can't use Machine method get_polar_eq: " + str( get_polar_eq)))) else: get_polar_eq = get_polar_eq # save method is available in all object save = save def __init__( self, rotor=-1, stator=-1, frame=-1, shaft=-1, name="default_machine", desc="", init_dict=None, ): """Constructor of the class. Can be use in two ways : - __init__ (arg1 = 1, arg3 = 5) every parameters have name and default values for Matrix, None will initialise the property with an empty Matrix for pyleecan type, None will call the default constructor - __init__ (init_dict = d) d must be a dictionnary wiht every properties as keys ndarray or list can be given for Vector and Matrix object or dict can be given for pyleecan Object""" if rotor == -1: rotor = Lamination() if stator == -1: stator = Lamination() if frame == -1: frame = Frame() if shaft == -1: shaft = Shaft() if init_dict is not None: # Initialisation by dict check_init_dict( init_dict, ["rotor", "stator", "frame", "shaft", "name", "desc"]) # Overwrite default value with init_dict content if "rotor" in list(init_dict.keys()): rotor = init_dict["rotor"] if "stator" in list(init_dict.keys()): stator = init_dict["stator"] if "frame" in list(init_dict.keys()): frame = init_dict["frame"] if "shaft" in list(init_dict.keys()): shaft = init_dict["shaft"] if "name" in list(init_dict.keys()): name = init_dict["name"] if "desc" in list(init_dict.keys()): desc = init_dict["desc"] # Initialisation by argument self.parent = None # rotor can be None, a Lamination object or a dict if isinstance(rotor, dict): # Check that the type is correct (including daughter) class_name = rotor.get("__class__") if class_name not in [ "Lamination", "LamHole", "LamSlot", "LamSlotWind", "LamSlotMag", "LamSquirrelCage", ]: raise InitUnKnowClassError("Unknow class name " + class_name + " in init_dict for rotor") # Dynamic import to call the correct constructor module = __import__("pyleecan.Classes." + class_name, fromlist=[class_name]) class_obj = getattr(module, class_name) self.rotor = class_obj(init_dict=rotor) else: self.rotor = rotor # stator can be None, a Lamination object or a dict if isinstance(stator, dict): # Check that the type is correct (including daughter) class_name = stator.get("__class__") if class_name not in [ "Lamination", "LamHole", "LamSlot", "LamSlotWind", "LamSlotMag", "LamSquirrelCage", ]: raise InitUnKnowClassError("Unknow class name " + class_name + " in init_dict for stator") # Dynamic import to call the correct constructor module = __import__("pyleecan.Classes." + class_name, fromlist=[class_name]) class_obj = getattr(module, class_name) self.stator = class_obj(init_dict=stator) else: self.stator = stator # frame can be None, a Frame object or a dict if isinstance(frame, dict): self.frame = Frame(init_dict=frame) else: self.frame = frame # shaft can be None, a Shaft object or a dict if isinstance(shaft, dict): self.shaft = Shaft(init_dict=shaft) else: self.shaft = shaft self.name = name self.desc = desc # The class is frozen, for now it's impossible to add new properties self._freeze() def __str__(self): """Convert this objet in a readeable string (for print)""" Machine_str = "" if self.parent is None: Machine_str += "parent = None " + linesep else: Machine_str += "parent = " + str(type( self.parent)) + " object" + linesep Machine_str += "rotor = " + str( self.rotor.as_dict()) + linesep + linesep Machine_str += "stator = " + str( self.stator.as_dict()) + linesep + linesep Machine_str += "frame = " + str( self.frame.as_dict()) + linesep + linesep Machine_str += "shaft = " + str( self.shaft.as_dict()) + linesep + linesep Machine_str += 'name = "' + str(self.name) + '"' + linesep Machine_str += 'desc = "' + str(self.desc) + '"' return Machine_str def __eq__(self, other): """Compare two objects (skip parent)""" if type(other) != type(self): return False if other.rotor != self.rotor: return False if other.stator != self.stator: return False if other.frame != self.frame: return False if other.shaft != self.shaft: return False if other.name != self.name: return False if other.desc != self.desc: return False return True def as_dict(self): """Convert this objet in a json seriable dict (can be use in __init__) """ Machine_dict = dict() if self.rotor is None: Machine_dict["rotor"] = None else: Machine_dict["rotor"] = self.rotor.as_dict() if self.stator is None: Machine_dict["stator"] = None else: Machine_dict["stator"] = self.stator.as_dict() if self.frame is None: Machine_dict["frame"] = None else: Machine_dict["frame"] = self.frame.as_dict() if self.shaft is None: Machine_dict["shaft"] = None else: Machine_dict["shaft"] = self.shaft.as_dict() Machine_dict["name"] = self.name Machine_dict["desc"] = self.desc # The class name is added to the dict fordeserialisation purpose Machine_dict["__class__"] = "Machine" return Machine_dict def _set_None(self): """Set all the properties to None (except pyleecan object)""" if self.rotor is not None: self.rotor._set_None() if self.stator is not None: self.stator._set_None() if self.frame is not None: self.frame._set_None() if self.shaft is not None: self.shaft._set_None() self.name = None self.desc = None def _get_rotor(self): """getter of rotor""" return self._rotor def _set_rotor(self, value): """setter of rotor""" check_var("rotor", value, "Lamination") self._rotor = value if self._rotor is not None: self._rotor.parent = self # Machine's Rotor # Type : Lamination rotor = property(fget=_get_rotor, fset=_set_rotor, doc=u"""Machine's Rotor""") def _get_stator(self): """getter of stator""" return self._stator def _set_stator(self, value): """setter of stator""" check_var("stator", value, "Lamination") self._stator = value if self._stator is not None: self._stator.parent = self # Machine's Stator # Type : Lamination stator = property(fget=_get_stator, fset=_set_stator, doc=u"""Machine's Stator""") def _get_frame(self): """getter of frame""" return self._frame def _set_frame(self, value): """setter of frame""" check_var("frame", value, "Frame") self._frame = value if self._frame is not None: self._frame.parent = self # Machine's Frame # Type : Frame frame = property(fget=_get_frame, fset=_set_frame, doc=u"""Machine's Frame""") def _get_shaft(self): """getter of shaft""" return self._shaft def _set_shaft(self, value): """setter of shaft""" check_var("shaft", value, "Shaft") self._shaft = value if self._shaft is not None: self._shaft.parent = self # Machine's Shaft # Type : Shaft shaft = property(fget=_get_shaft, fset=_set_shaft, doc=u"""Machine's Shaft""") def _get_name(self): """getter of name""" return self._name def _set_name(self, value): """setter of name""" check_var("name", value, "str") self._name = value # Name of the machine # Type : str name = property(fget=_get_name, fset=_set_name, doc=u"""Name of the machine""") def _get_desc(self): """getter of desc""" return self._desc def _set_desc(self, value): """setter of desc""" check_var("desc", value, "str") self._desc = value # Machine description # Type : str desc = property(fget=_get_desc, fset=_set_desc, doc=u"""Machine description""")
class Machine(FrozenClass): """Abstract class for machines""" VERSION = 1 # cf Methods.Machine.Machine.build_geometry build_geometry = build_geometry # cf Methods.Machine.Machine.check check = check # cf Methods.Machine.Machine.comp_masses comp_masses = comp_masses # cf Methods.Machine.Machine.comp_width_airgap_mag comp_width_airgap_mag = comp_width_airgap_mag # cf Methods.Machine.Machine.comp_width_airgap_mec comp_width_airgap_mec = comp_width_airgap_mec # cf Methods.Machine.Machine.get_lamination get_lamination = get_lamination # cf Methods.Machine.Machine.comp_Rgap_mec comp_Rgap_mec = comp_Rgap_mec # cf Methods.Machine.Machine.plot plot = plot # cf Methods.Machine.Machine.comp_output_geo comp_output_geo = comp_output_geo # cf Methods.Machine.Machine.comp_length_airgap_active comp_length_airgap_active = comp_length_airgap_active # cf Methods.Machine.Machine.get_polar_eq get_polar_eq = get_polar_eq # save method is available in all object save = save def __init__( self, rotor=-1, stator=-1, frame=-1, shaft=-1, name="default_machine", desc="", init_dict=None, ): """Constructor of the class. Can be use in two ways : - __init__ (arg1 = 1, arg3 = 5) every parameters have name and default values for Matrix, None will initialise the property with an empty Matrix for pyleecan type, None will call the default constructor - __init__ (init_dict = d) d must be a dictionnary wiht every properties as keys ndarray or list can be given for Vector and Matrix object or dict can be given for pyleecan Object""" if rotor == -1: rotor = Lamination() if stator == -1: stator = Lamination() if frame == -1: frame = Frame() if shaft == -1: shaft = Shaft() if init_dict is not None: # Initialisation by dict check_init_dict( init_dict, ["rotor", "stator", "frame", "shaft", "name", "desc"]) # Overwrite default value with init_dict content if "rotor" in list(init_dict.keys()): rotor = init_dict["rotor"] if "stator" in list(init_dict.keys()): stator = init_dict["stator"] if "frame" in list(init_dict.keys()): frame = init_dict["frame"] if "shaft" in list(init_dict.keys()): shaft = init_dict["shaft"] if "name" in list(init_dict.keys()): name = init_dict["name"] if "desc" in list(init_dict.keys()): desc = init_dict["desc"] # Initialisation by argument self.parent = None # rotor can be None, a Lamination object or a dict if isinstance(rotor, dict): # Call the correct constructor according to the dict load_dict = { "LamHole": LamHole, "LamSlot": LamSlot, "LamSlotWind": LamSlotWind, "LamSlotMag": LamSlotMag, "LamSquirrelCage": LamSquirrelCage, "Lamination": Lamination, } obj_class = rotor.get("__class__") if obj_class is None: self.rotor = Lamination(init_dict=rotor) elif obj_class in list(load_dict.keys()): self.rotor = load_dict[obj_class](init_dict=rotor) else: # Avoid generation error or wrong modification in json raise InitUnKnowClassError( "Unknow class name in init_dict for rotor") else: self.rotor = rotor # stator can be None, a Lamination object or a dict if isinstance(stator, dict): # Call the correct constructor according to the dict load_dict = { "LamHole": LamHole, "LamSlot": LamSlot, "LamSlotWind": LamSlotWind, "LamSlotMag": LamSlotMag, "LamSquirrelCage": LamSquirrelCage, "Lamination": Lamination, } obj_class = stator.get("__class__") if obj_class is None: self.stator = Lamination(init_dict=stator) elif obj_class in list(load_dict.keys()): self.stator = load_dict[obj_class](init_dict=stator) else: # Avoid generation error or wrong modification in json raise InitUnKnowClassError( "Unknow class name in init_dict for stator") else: self.stator = stator # frame can be None, a Frame object or a dict if isinstance(frame, dict): self.frame = Frame(init_dict=frame) else: self.frame = frame # shaft can be None, a Shaft object or a dict if isinstance(shaft, dict): self.shaft = Shaft(init_dict=shaft) else: self.shaft = shaft self.name = name self.desc = desc # The class is frozen, for now it's impossible to add new properties self._freeze() def __str__(self): """Convert this objet in a readeable string (for print)""" Machine_str = "" if self.parent is None: Machine_str += "parent = None " + linesep else: Machine_str += "parent = " + str(type( self.parent)) + " object" + linesep Machine_str += "rotor = " + str( self.rotor.as_dict()) + linesep + linesep Machine_str += "stator = " + str( self.stator.as_dict()) + linesep + linesep Machine_str += "frame = " + str( self.frame.as_dict()) + linesep + linesep Machine_str += "shaft = " + str( self.shaft.as_dict()) + linesep + linesep Machine_str += 'name = "' + str(self.name) + '"' + linesep Machine_str += 'desc = "' + str(self.desc) + '"' return Machine_str def __eq__(self, other): """Compare two objects (skip parent)""" if type(other) != type(self): return False if other.rotor != self.rotor: return False if other.stator != self.stator: return False if other.frame != self.frame: return False if other.shaft != self.shaft: return False if other.name != self.name: return False if other.desc != self.desc: return False return True def as_dict(self): """Convert this objet in a json seriable dict (can be use in __init__) """ Machine_dict = dict() if self.rotor is None: Machine_dict["rotor"] = None else: Machine_dict["rotor"] = self.rotor.as_dict() if self.stator is None: Machine_dict["stator"] = None else: Machine_dict["stator"] = self.stator.as_dict() if self.frame is None: Machine_dict["frame"] = None else: Machine_dict["frame"] = self.frame.as_dict() if self.shaft is None: Machine_dict["shaft"] = None else: Machine_dict["shaft"] = self.shaft.as_dict() Machine_dict["name"] = self.name Machine_dict["desc"] = self.desc # The class name is added to the dict fordeserialisation purpose Machine_dict["__class__"] = "Machine" return Machine_dict def _set_None(self): """Set all the properties to None (except pyleecan object)""" if self.rotor is not None: self.rotor._set_None() if self.stator is not None: self.stator._set_None() if self.frame is not None: self.frame._set_None() if self.shaft is not None: self.shaft._set_None() self.name = None self.desc = None def _get_rotor(self): """getter of rotor""" return self._rotor def _set_rotor(self, value): """setter of rotor""" check_var("rotor", value, "Lamination") self._rotor = value if self._rotor is not None: self._rotor.parent = self # Machine's Rotor # Type : Lamination rotor = property(fget=_get_rotor, fset=_set_rotor, doc=u"""Machine's Rotor""") def _get_stator(self): """getter of stator""" return self._stator def _set_stator(self, value): """setter of stator""" check_var("stator", value, "Lamination") self._stator = value if self._stator is not None: self._stator.parent = self # Machine's Stator # Type : Lamination stator = property(fget=_get_stator, fset=_set_stator, doc=u"""Machine's Stator""") def _get_frame(self): """getter of frame""" return self._frame def _set_frame(self, value): """setter of frame""" check_var("frame", value, "Frame") self._frame = value if self._frame is not None: self._frame.parent = self # Machine's Frame # Type : Frame frame = property(fget=_get_frame, fset=_set_frame, doc=u"""Machine's Frame""") def _get_shaft(self): """getter of shaft""" return self._shaft def _set_shaft(self, value): """setter of shaft""" check_var("shaft", value, "Shaft") self._shaft = value if self._shaft is not None: self._shaft.parent = self # Machine's Shaft # Type : Shaft shaft = property(fget=_get_shaft, fset=_set_shaft, doc=u"""Machine's Shaft""") def _get_name(self): """getter of name""" return self._name def _set_name(self, value): """setter of name""" check_var("name", value, "str") self._name = value # Name of the machine # Type : str name = property(fget=_get_name, fset=_set_name, doc=u"""Name of the machine""") def _get_desc(self): """getter of desc""" return self._desc def _set_desc(self, value): """setter of desc""" check_var("desc", value, "str") self._desc = value # Machine description # Type : str desc = property(fget=_get_desc, fset=_set_desc, doc=u"""Machine description""")
class Machine(FrozenClass): """Abstract class for machines""" VERSION = 1 # Check ImportError to remove unnecessary dependencies in unused method # cf Methods.Machine.Machine.build_geometry if isinstance(build_geometry, ImportError): build_geometry = property(fget=lambda x: raise_( ImportError("Can't use Machine method build_geometry: " + str( build_geometry)))) else: build_geometry = build_geometry # cf Methods.Machine.Machine.check if isinstance(check, ImportError): check = property(fget=lambda x: raise_( ImportError("Can't use Machine method check: " + str(check)))) else: check = check # cf Methods.Machine.Machine.comp_masses if isinstance(comp_masses, ImportError): comp_masses = property(fget=lambda x: raise_( ImportError("Can't use Machine method comp_masses: " + str( comp_masses)))) else: comp_masses = comp_masses # cf Methods.Machine.Machine.comp_width_airgap_mag if isinstance(comp_width_airgap_mag, ImportError): comp_width_airgap_mag = property(fget=lambda x: raise_( ImportError("Can't use Machine method comp_width_airgap_mag: " + str(comp_width_airgap_mag)))) else: comp_width_airgap_mag = comp_width_airgap_mag # cf Methods.Machine.Machine.comp_width_airgap_mec if isinstance(comp_width_airgap_mec, ImportError): comp_width_airgap_mec = property(fget=lambda x: raise_( ImportError("Can't use Machine method comp_width_airgap_mec: " + str(comp_width_airgap_mec)))) else: comp_width_airgap_mec = comp_width_airgap_mec # cf Methods.Machine.Machine.get_lamination if isinstance(get_lamination, ImportError): get_lamination = property(fget=lambda x: raise_( ImportError("Can't use Machine method get_lamination: " + str( get_lamination)))) else: get_lamination = get_lamination # cf Methods.Machine.Machine.comp_Rgap_mec if isinstance(comp_Rgap_mec, ImportError): comp_Rgap_mec = property(fget=lambda x: raise_( ImportError("Can't use Machine method comp_Rgap_mec: " + str( comp_Rgap_mec)))) else: comp_Rgap_mec = comp_Rgap_mec # cf Methods.Machine.Machine.plot if isinstance(plot, ImportError): plot = property(fget=lambda x: raise_( ImportError("Can't use Machine method plot: " + str(plot)))) else: plot = plot # cf Methods.Machine.Machine.comp_output_geo if isinstance(comp_output_geo, ImportError): comp_output_geo = property(fget=lambda x: raise_( ImportError("Can't use Machine method comp_output_geo: " + str( comp_output_geo)))) else: comp_output_geo = comp_output_geo # cf Methods.Machine.Machine.comp_length_airgap_active if isinstance(comp_length_airgap_active, ImportError): comp_length_airgap_active = property(fget=lambda x: raise_( ImportError("Can't use Machine method comp_length_airgap_active: " + str(comp_length_airgap_active)))) else: comp_length_airgap_active = comp_length_airgap_active # cf Methods.Machine.Machine.get_polar_eq if isinstance(get_polar_eq, ImportError): get_polar_eq = property(fget=lambda x: raise_( ImportError("Can't use Machine method get_polar_eq: " + str( get_polar_eq)))) else: get_polar_eq = get_polar_eq # cf Methods.Machine.Machine.plot_anim_rotor if isinstance(plot_anim_rotor, ImportError): plot_anim_rotor = property(fget=lambda x: raise_( ImportError("Can't use Machine method plot_anim_rotor: " + str( plot_anim_rotor)))) else: plot_anim_rotor = plot_anim_rotor # save method is available in all object save = save def __init__( self, frame=-1, shaft=-1, name="default_machine", desc="", type_machine=1, init_dict=None, ): """Constructor of the class. Can be use in two ways : - __init__ (arg1 = 1, arg3 = 5) every parameters have name and default values for Matrix, None will initialise the property with an empty Matrix for pyleecan type, None will call the default constructor - __init__ (init_dict = d) d must be a dictionnary wiht every properties as keys ndarray or list can be given for Vector and Matrix object or dict can be given for pyleecan Object""" if frame == -1: frame = Frame() if shaft == -1: shaft = Shaft() if init_dict is not None: # Initialisation by dict check_init_dict(init_dict, ["frame", "shaft", "name", "desc", "type_machine"]) # Overwrite default value with init_dict content if "frame" in list(init_dict.keys()): frame = init_dict["frame"] if "shaft" in list(init_dict.keys()): shaft = init_dict["shaft"] if "name" in list(init_dict.keys()): name = init_dict["name"] if "desc" in list(init_dict.keys()): desc = init_dict["desc"] if "type_machine" in list(init_dict.keys()): type_machine = init_dict["type_machine"] # Initialisation by argument self.parent = None # frame can be None, a Frame object or a dict if isinstance(frame, dict): self.frame = Frame(init_dict=frame) else: self.frame = frame # shaft can be None, a Shaft object or a dict if isinstance(shaft, dict): self.shaft = Shaft(init_dict=shaft) else: self.shaft = shaft self.name = name self.desc = desc self.type_machine = type_machine # The class is frozen, for now it's impossible to add new properties self._freeze() def __str__(self): """Convert this objet in a readeable string (for print)""" Machine_str = "" if self.parent is None: Machine_str += "parent = None " + linesep else: Machine_str += "parent = " + str(type( self.parent)) + " object" + linesep if self.frame is not None: tmp = self.frame.__str__().replace(linesep, linesep + "\t").rstrip("\t") Machine_str += "frame = " + tmp else: Machine_str += "frame = None" + linesep + linesep if self.shaft is not None: tmp = self.shaft.__str__().replace(linesep, linesep + "\t").rstrip("\t") Machine_str += "shaft = " + tmp else: Machine_str += "shaft = None" + linesep + linesep Machine_str += 'name = "' + str(self.name) + '"' + linesep Machine_str += 'desc = "' + str(self.desc) + '"' + linesep Machine_str += "type_machine = " + str(self.type_machine) + linesep return Machine_str def __eq__(self, other): """Compare two objects (skip parent)""" if type(other) != type(self): return False if other.frame != self.frame: return False if other.shaft != self.shaft: return False if other.name != self.name: return False if other.desc != self.desc: return False if other.type_machine != self.type_machine: return False return True def as_dict(self): """Convert this objet in a json seriable dict (can be use in __init__) """ Machine_dict = dict() if self.frame is None: Machine_dict["frame"] = None else: Machine_dict["frame"] = self.frame.as_dict() if self.shaft is None: Machine_dict["shaft"] = None else: Machine_dict["shaft"] = self.shaft.as_dict() Machine_dict["name"] = self.name Machine_dict["desc"] = self.desc Machine_dict["type_machine"] = self.type_machine # The class name is added to the dict fordeserialisation purpose Machine_dict["__class__"] = "Machine" return Machine_dict def _set_None(self): """Set all the properties to None (except pyleecan object)""" if self.frame is not None: self.frame._set_None() if self.shaft is not None: self.shaft._set_None() self.name = None self.desc = None self.type_machine = None def _get_frame(self): """getter of frame""" return self._frame def _set_frame(self, value): """setter of frame""" check_var("frame", value, "Frame") self._frame = value if self._frame is not None: self._frame.parent = self # Machine's Frame # Type : Frame frame = property(fget=_get_frame, fset=_set_frame, doc=u"""Machine's Frame""") def _get_shaft(self): """getter of shaft""" return self._shaft def _set_shaft(self, value): """setter of shaft""" check_var("shaft", value, "Shaft") self._shaft = value if self._shaft is not None: self._shaft.parent = self # Machine's Shaft # Type : Shaft shaft = property(fget=_get_shaft, fset=_set_shaft, doc=u"""Machine's Shaft""") def _get_name(self): """getter of name""" return self._name def _set_name(self, value): """setter of name""" check_var("name", value, "str") self._name = value # Name of the machine # Type : str name = property(fget=_get_name, fset=_set_name, doc=u"""Name of the machine""") def _get_desc(self): """getter of desc""" return self._desc def _set_desc(self, value): """setter of desc""" check_var("desc", value, "str") self._desc = value # Machine description # Type : str desc = property(fget=_get_desc, fset=_set_desc, doc=u"""Machine description""") def _get_type_machine(self): """getter of type_machine""" return self._type_machine def _set_type_machine(self, value): """setter of type_machine""" check_var("type_machine", value, "int") self._type_machine = value # Integer to store the machine type (for the GUI, should be replaced by a test of the object type) # Type : int type_machine = property( fget=_get_type_machine, fset=_set_type_machine, doc= u"""Integer to store the machine type (for the GUI, should be replaced by a test of the object type)""", )