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 test_Lam_Mag_11_surface(self):
"""Test machine plot with Magnet 11 surface"""
plt.close("all")
test_obj = Machine()
test_obj.rotor = LamSlotMag(
Rint=40e-3,
Rext=90e-3,
is_internal=True,
is_stator=False,
L1=0.45,
Nrvd=1,
Wrvd=0.05,
)
magnet = [MagnetType11(Lmag=0.5, Hmag=0.01, Wmag=pi / 8)]
test_obj.rotor.slot = SlotMPolar(Zs=8, W0=pi / 8, magnet=magnet)
test_obj.rotor.mat_type.magnetics = MatLamination(Wlam=0.5e-3)
test_obj.shaft = Shaft(Drsh=test_obj.rotor.Rint * 2, Lshaft=0.55)
test_obj.stator = LamSlotMag(
Rint=115e-3,
Rext=200e-3,
is_internal=False,
is_stator=True,
L1=0.45,
Nrvd=1,
Wrvd=0.05,
)
magnet2 = [MagnetType11(Lmag=0.5, Hmag=0.01, Wmag=pi / 4)]
test_obj.stator.slot = SlotMPolar(Zs=4, W0=pi / 4, magnet=magnet2)
test_obj.stator.mat_type.magnetics = MatLamination(Wlam=0.5e-3)
test_obj.frame = Frame(Rint=200e-3, Rext=200e-3, Lfra=0.5)
test_obj.plot()
fig = plt.gcf()
self.assertEqual(len(fig.axes[0].patches), 17)
fig.savefig(join(save_path, "test_Lam_Mag_11s_1-Machine.png"))
test_obj.rotor.plot()
fig = plt.gcf()
self.assertEqual(len(fig.axes[0].patches), 10)
fig.savefig(join(save_path, "test_Lam_Mag_11s_2-Rotor.png"))
test_obj.stator.plot()
fig = plt.gcf()
patches = fig.axes[0].patches
self.assertEqual(len(patches), 6)
self.assertTrue(isinstance(patches[0], Circle))
self.assertEqual(patches[0].get_radius(), 200e-3)
self.assertEqual(patches[0].get_facecolor(),
(0.0, 0.0, 1.0, 1.0)) # Blue
for i in range(1, 6):
self.assertTrue(isinstance(patches[i], Polygon))
if i == 1: # Lamination inner
self.assertEqual(patches[i].get_facecolor(),
(1.0, 1.0, 1.0, 1.0)) # White
else: # Magnet
self.assertEqual(patches[i].get_facecolor(),
(0.75, 0.75, 0.75, 1.0)) # Gray
fig.savefig(join(save_path, "test_Lam_Mag_11s_3-Stator.png"))
def clear_frame(self, is_checked):
"""Signal to remove the frame if the checkbox is unchecked
Parameters
----------
self : SMachineDimension
A SMachineDimension object
is_checked : bool
State of the g_frame checkbox
"""
if is_checked:
self.machine.frame = Frame()
self.machine.frame._set_None()
if self.machine.stator.Rext is not None:
self.machine.frame.Rint = self.machine.stator.Rext
self.machine.frame.Rext = self.machine.stator.Rext
else:
self.machine.frame.Rint = None
self.machine.frame.Rext = None
self.lf_Wfra.clear()
self.lf_Lfra.clear()
self.in_Lfra.show()
self.unit_Lfra.show()
else:
self.machine.frame = None
# Notify the machine GUI that the machine has changed
self.saveNeeded.emit()
def setUp(self):
"""Run at the begining of every test to setup the machine"""
plt.close("all")
test_obj = Machine()
test_obj.rotor = LamHole(Rint=45e-3 / 2,
Rext=81.5e-3,
is_stator=False,
is_internal=True,
L1=0.9)
test_obj.rotor.hole = list()
test_obj.rotor.hole.append(
HoleM51(
Zh=8,
W0=0.016,
W1=pi / 6,
W2=0.004,
W3=0.01,
W4=0.002,
W5=0.01,
W6=0.002,
W7=0.01,
H0=0.01096,
H1=0.0015,
H2=0.0055,
))
test_obj.shaft = Shaft(Drsh=test_obj.rotor.Rint * 2, Lshaft=1.2)
test_obj.stator = Lamination(Rint=0.09,
Rext=0.12,
is_internal=False,
is_stator=True,
L1=0.9)
test_obj.frame = Frame(Rint=0.12, Rext=0.12, Lfra=0.7)
self.test_obj = test_obj
def __init__(
self,
rotor=-1,
stator=-1,
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 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", "type_machine"],
)
# 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"]
if "type_machine" in list(init_dict.keys()):
type_machine = init_dict["type_machine"]
# Initialisation by argument
# Call MachineDFIM init
super(MachineSCIM, self).__init__(
rotor=rotor,
stator=stator,
frame=frame,
shaft=shaft,
name=name,
desc=desc,
type_machine=type_machine,
)
def test_Lam_Wind_28_wind_rad_tan(self):
"""Test machine plot with Slot 28 and winding rad=1, tan=2 and rad=2 and tan=1
"""
print("\nTest plot Slot 28")
plt.close("all")
test_obj = Machine()
test_obj.rotor = LamSlotWind(
Rint=35e-3,
Rext=84e-3,
is_internal=True,
is_stator=False,
L1=0.9,
Nrvd=2,
Wrvd=0.05,
)
test_obj.rotor.axial_vent = [
VentilationCirc(Zh=6, Alpha0=pi / 6, D0=15e-3, H0=0.045)
]
test_obj.rotor.slot = SlotW28(
Zs=42, W0=3.5e-3, H0=0.45e-3, R1=3.5e-3, H3=14e-3, W3=5e-3
)
test_obj.rotor.winding = WindingCW2LT(qs=3, p=3)
test_obj.rotor.mat_type.magnetics = MatLamination(Wlam=0.5e-3)
test_obj.shaft = Shaft(Drsh=test_obj.rotor.Rint * 2, Lshaft=1)
test_obj.stator = LamSlotWind(
Rint=85e-3,
Rext=0.2,
is_internal=False,
is_stator=True,
L1=0.9,
Nrvd=2,
Wrvd=0.05,
)
test_obj.stator.slot = SlotW28(
Zs=18, W0=7e-3, R1=10e-3, H0=5e-3, H3=30e-3, W3=5e-3
)
test_obj.stator.winding = WindingDW2L(qs=3, p=3, Lewout=60e-3)
test_obj.stator.mat_type.magnetics = MatLamination(Wlam=0.5e-3)
test_obj.frame = Frame(Rint=0.2, Rext=0.25, Lfra=1)
test_obj.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s28_1-Machine.png"))
# Rotor + stator + 2 for frame + 1 for Shaft
self.assertEqual(len(fig.axes[0].patches), 133)
test_obj.rotor.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s28_2-Rotor.png"))
# 2 for lam + Zs*2 for wind + 6 vent
self.assertEqual(len(fig.axes[0].patches), 92)
test_obj.stator.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s28_3-Stator.png"))
# 2 for lam, 2*Zs for wind
self.assertEqual(len(fig.axes[0].patches), 38)
def test_Lam_Mag_10_surface(self):
"""Test machine plot with Magnet 10 surface"""
plt.close("all")
test_obj = Machine()
test_obj.rotor = LamSlotMag(
Rint=40e-3,
Rext=200e-3,
is_internal=True,
is_stator=False,
L1=0.5,
Nrvd=0,
Wrvd=0.05,
)
magnet = [MagnetType10(Lmag=0.5, Hmag=0.02, Wmag=0.08)]
test_obj.rotor.slot = SlotMFlat(Zs=8,
H0=0,
W0=2 * pi / 10,
W0_is_rad=True,
magnet=magnet)
test_obj.rotor.mat_type.magnetics = MatLamination(Wlam=0.5e-3)
test_obj.shaft = Shaft(Drsh=test_obj.rotor.Rint * 2, Lshaft=0.55)
test_obj.stator = Lamination(
Rint=230e-3,
Rext=0.3,
is_internal=False,
is_stator=True,
L1=0.5,
Nrvd=0,
Wrvd=0.05,
)
test_obj.stator.mat_type.magnetics = MatLamination(Wlam=0.5e-3)
test_obj.frame = Frame(Rint=200e-3, Rext=250e-3, Lfra=0.5)
test_obj.plot()
fig = plt.gcf()
self.assertEqual(len(fig.axes[0].patches), 15)
fig.savefig(join(save_path, "test_Lam_Mag_10s_1-Machine.png"))
test_obj.rotor.plot()
fig = plt.gcf()
self.assertEqual(len(fig.axes[0].patches), 10)
fig.savefig(join(save_path, "test_Lam_Mag_10s_2-Rotor.png"))
test_obj.stator.plot()
fig = plt.gcf()
self.assertEqual(len(fig.axes[0].patches), 2)
fig.savefig(join(save_path, "test_Lam_Mag_10s_3-Stator.png"))
magnet2 = [MagnetType10(Lmag=0.5, Hmag=0.02, Wmag=0.04)]
test_obj.rotor.slot = SlotMFlat(Zs=8,
W0=0.04,
W0_is_rad=False,
magnet=magnet2)
test_obj.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Mag_10s_5-Rotor 2.png"))
def test_Lam_Wind_24_wind_22(self):
"""Test machine plot with Slot 24 and winding rad=2, tan=2
"""
print("\nTest plot Slot 24")
plt.close("all")
test_obj = Machine()
test_obj.rotor = LamSlotWind(
Rint=0.2,
Rext=0.5,
is_internal=True,
is_stator=False,
L1=0.8,
Nrvd=4,
Wrvd=0.05,
)
test_obj.rotor.slot = SlotW24(Zs=6, W3=100e-3, H2=150e-3)
test_obj.rotor.winding = WindingUD(user_wind_mat=wind_mat,
qs=4,
p=4,
Lewout=120e-3)
test_obj.rotor.mat_type.magnetics = MatLamination(Wlam=0.5e-3)
test_obj.shaft = Shaft(Drsh=test_obj.rotor.Rint * 2, Lshaft=1)
test_obj.stator = LamSlotWind(
Rint=0.51,
Rext=0.8,
is_internal=False,
is_stator=True,
L1=0.8,
Nrvd=4,
Wrvd=0.05,
)
test_obj.stator.slot = SlotW24(Zs=18, W3=50e-3, H2=200e-3)
test_obj.stator.winding = WindingDW2L(qs=3, p=3)
test_obj.stator.mat_type.magnetics = MatLamination(Wlam=0.5e-3)
test_obj.stator.winding.Lewout = 120e-3
test_obj.frame = Frame(Rint=0.8, Rext=0.8, Lfra=1)
test_obj.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s24_1-Machine.png"))
# Rotor + Stator + 0 for frame + 1 for shaft
self.assertEqual(len(fig.axes[0].patches), 65)
test_obj.rotor.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s24_2-Rotor.png"))
# 2 for lam + 4*Zs for wind
self.assertEqual(len(fig.axes[0].patches), 26)
test_obj.stator.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s24_3-Stator.png"))
# 2 for lam + 2*Zs for wind
self.assertEqual(len(fig.axes[0].patches), 38)
def test_Lam_Mag_13_inset(self):
"""Test machine plot with Magnet 12 inset"""
plt.close("all")
test_obj = Machine()
test_obj.rotor = LamSlotMag(
Rint=40e-3,
Rext=90e-3,
is_internal=True,
is_stator=False,
L1=0.42,
Nrvd=4,
Wrvd=0.02,
)
magnet = [MagnetType13(Lmag=0.5, Hmag=0.02, Wmag=0.04, Rtop=0.04)]
test_obj.rotor.slot = SlotMFlat(Zs=8,
W0=0.04,
H0=0.02,
W3=2 * pi / 64,
magnet=magnet)
test_obj.rotor.mat_type.mag = MatLamination(Wlam=0.5e-3)
test_obj.shaft = Shaft(Drsh=test_obj.rotor.Rint * 2, Lshaft=0.55)
test_obj.stator = LamSlotMag(
Rint=110e-3,
Rext=200e-3,
is_internal=False,
is_stator=True,
L1=0.42,
Nrvd=4,
Wrvd=0.02,
)
magnet2 = [MagnetType13(Lmag=0.5, Hmag=0.02, Wmag=0.04, Rtop=0.04)]
test_obj.stator.slot = SlotMFlat(Zs=4,
W0=0.04,
H0=0.025,
W3=2 * pi / 64,
magnet=magnet2)
test_obj.stator.mat_type.mag = MatLamination(Wlam=0.5e-3)
test_obj.frame = Frame(Rint=200e-3, Rext=250e-3, Lfra=0.5)
test_obj.plot()
fig = plt.gcf()
self.assertEqual(len(fig.axes[0].patches), 19)
fig.savefig(join(save_path, "test_Lam_Mag_13i_1-Machine.png"))
test_obj.rotor.plot()
fig = plt.gcf()
self.assertEqual(len(fig.axes[0].patches), 10)
fig.savefig(join(save_path, "test_Lam_Mag_13i_2-Rotor.png"))
test_obj.stator.plot()
fig = plt.gcf()
self.assertEqual(len(fig.axes[0].patches), 6)
fig.savefig(join(save_path, "test_Lam_Mag_13i_3-Stator.png"))
def test_Lam_Mag_14_inset(self):
"""Test machine plot with Magnet 14 inset"""
plt.close("all")
test_obj = Machine()
test_obj.rotor = LamSlotMag(
Rint=40e-3,
Rext=90e-3,
is_internal=True,
is_stator=False,
L1=0.4,
Nrvd=5,
Wrvd=0.02,
)
magnet = [MagnetType14(Lmag=0.5, Hmag=0.02, Wmag=0.628, Rtop=0.04)]
test_obj.rotor.slot = SlotMPolar(Zs=4,
W0=0.628,
H0=0.02,
magnet=magnet)
test_obj.rotor.mat_type.magnetics = MatLamination(Wlam=0.5e-3)
test_obj.shaft = Shaft(Drsh=test_obj.rotor.Rint * 2, Lshaft=0.55)
test_obj.stator = Lamination(
Rint=130e-3,
Rext=0.2,
is_internal=False,
is_stator=True,
L1=0.4,
Nrvd=5,
Wrvd=0.02,
)
test_obj.stator.mat_type.magnetics = MatLamination(Wlam=0.5e-3)
test_obj.frame = Frame(Rint=200e-3, Rext=250e-3, Lfra=0.5)
test_obj.plot()
fig = plt.gcf()
self.assertEqual(len(fig.axes[0].patches), 11)
fig.savefig(join(save_path, "test_Lam_Mag_14i_1-Machine.png"))
test_obj.rotor.plot()
fig = plt.gcf()
self.assertEqual(len(fig.axes[0].patches), 6)
fig.savefig(join(save_path, "test_Lam_Mag_14i_2-Rotor.png"))
test_obj.stator.plot()
fig = plt.gcf()
self.assertEqual(len(fig.axes[0].patches), 2)
fig.savefig(join(save_path, "test_Lam_Mag_14i_3-Stator.png"))
def setUp(self):
"""Run at the begining of every test to setup the machine"""
plt.close("all")
test_obj = Machine()
test_obj.rotor = LamHole(is_internal=True,
Rint=0.021,
Rext=0.075,
is_stator=False,
L1=0.7)
test_obj.rotor.hole = list()
test_obj.rotor.hole.append(
HoleM50(
Zh=8,
W0=50e-3,
W1=2e-3,
W2=1e-3,
W3=1e-3,
W4=20.6e-3,
H0=17.3e-3,
H1=1.25e-3,
H2=0.5e-3,
H3=6.8e-3,
H4=0,
))
test_obj.rotor.axial_vent = list()
test_obj.rotor.axial_vent.append(
VentilationCirc(Zh=8, Alpha0=0, D0=5e-3, H0=40e-3))
test_obj.rotor.axial_vent.append(
VentilationCirc(Zh=8, Alpha0=pi / 8, D0=7e-3, H0=40e-3))
test_obj.rotor.mat_type.magnetics = MatLamination(Wlam=0.5e-3)
test_obj.shaft = Shaft(Drsh=test_obj.rotor.Rint * 2, Lshaft=1.2)
test_obj.stator = Lamination(Rint=0.078,
Rext=0.104,
is_internal=False,
is_stator=True,
L1=0.8)
test_obj.stator.axial_vent.append(
VentilationPolar(Zh=8, H0=0.08, D0=0.01, W1=pi / 8, Alpha0=pi / 8))
test_obj.stator.axial_vent.append(
VentilationPolar(Zh=8, H0=0.092, D0=0.01, W1=pi / 8, Alpha0=0))
test_obj.stator.mat_type.magnetics = MatLamination(Wlam=0.5e-3)
test_obj.frame = Frame(Rint=0.104, Rext=0.114, Lfra=1)
self.test_obj = test_obj
def setUp(self):
"""Run at the begining of every test to setup the gui"""
self.test_obj = MachineSCIM()
self.test_obj.stator = LamSlotWind(is_stator=True,
is_internal=False,
Rint=0.21,
Rext=0.22)
self.test_obj.rotor = LamSlotWind(is_stator=False,
is_internal=True,
Rint=0.11,
Rext=0.12)
self.test_obj.frame = Frame(Rint=0.22, Rext=0.24, Lfra=0.25)
self.test_obj.shaft = Shaft(Lshaft=0.333,
Drsh=self.test_obj.rotor.Rint * 2)
self.widget = SMachineDimension(machine=self.test_obj,
matlib=[],
is_stator=False)
def setUp(self):
"""Run at the begining of every test to setup the machine"""
plt.close("all")
test_obj = MachineIPMSM()
test_obj.rotor = LamHole(
Rint=45e-3 / 2, Rext=81.5e-3, is_stator=False, is_internal=True, L1=0.9
)
test_obj.rotor.hole = list()
test_obj.rotor.hole.append(
HoleM52(Zh=8, W0=27e-3, W3=16.2e-3, H0=1e-3, H1=5e-3, H2=1e-3)
)
test_obj.shaft = Shaft(Drsh=test_obj.rotor.Rint * 2, Lshaft=1.2)
test_obj.stator = LamSlotWind(
Rint=0.09, Rext=0.12, is_internal=False, is_stator=True, L1=0.9, slot=None
)
test_obj.frame = Frame(Rint=0.12, Rext=0.12, Lfra=0.7)
self.test_obj = test_obj
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""")
def test_Lam_Wind_22_wind_22(self):
"""Test machine plot with Slot 22 and winding rad=2, tan=2
"""
print("\nTest plot Slot 22")
plt.close("all")
test_obj = MachineDFIM()
test_obj.rotor = LamSlotWind(
Rint=0,
Rext=0.5,
is_internal=True,
is_stator=False,
L1=0.8,
Nrvd=4,
Wrvd=0.05,
)
test_obj.rotor.slot = SlotW22(Zs=6,
W0=pi / 20,
W2=pi / 10,
H0=20e-3,
H2=150e-3)
test_obj.rotor.winding = WindingUD(user_wind_mat=wind_mat,
qs=4,
p=4,
Lewout=60e-3)
test_obj.rotor.mat_type.mag = MatMagnetics(Wlam=0.5e-3)
test_obj.shaft = Shaft(Drsh=test_obj.rotor.Rint * 2, Lshaft=1)
test_obj.stator = LamSlotWind(
Rint=0.51,
Rext=0.8,
is_internal=False,
is_stator=True,
L1=0.8,
Nrvd=4,
Wrvd=0.05,
)
test_obj.stator.slot = SlotW22(Zs=18,
W0=pi / 20,
W2=pi / 10,
H0=20e-3,
H2=150e-3)
test_obj.stator.winding = WindingDW2L(qs=3, p=3)
test_obj.stator.mat_type.mag = MatMagnetics(Wlam=0.5e-3)
test_obj.stator.winding.Lewout = 60e-3
test_obj.frame = Frame(Rint=0.8, Rext=0.8, Lfra=1)
test_obj.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s22_1-Machine.png"))
# Rotor + Stator + 0 for frame + 0 for shaft
self.assertEqual(len(fig.axes[0].patches), 63)
test_obj.rotor.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s22_2-Rotor.png"))
# 1 for lam + 4*Zs for wind
self.assertEqual(len(fig.axes[0].patches), 25)
test_obj.stator.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s22_3-Stator.png"))
# 2 for lam + Zs*2 for wind
self.assertEqual(len(fig.axes[0].patches), 38)
tooth = test_obj.rotor.slot.get_surface_tooth()
tooth.plot(color="r")
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s22_Tooth_in.png"))
tooth = test_obj.stator.slot.get_surface_tooth()
tooth.plot(color="r")
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s22_Tooth_out.png"))
def test_Lam_Wind_10_wind_22(self):
"""Test machine plot with Slot 10 and winding rad=2, tan=2
"""
print("\nTest plot Slot 10")
plt.close("all")
test_obj = Machine()
test_obj.rotor = LamSlotWind(
Rint=0.2,
Rext=0.5,
is_internal=True,
is_stator=False,
L1=0.95,
Nrvd=1,
Wrvd=0.05,
)
test_obj.rotor.slot = SlotW10(
Zs=6,
W0=50e-3,
W1=90e-3,
W2=100e-3,
H0=20e-3,
H1=35e-3,
H2=130e-3,
H1_is_rad=False,
)
test_obj.rotor.winding = WindingUD(user_wind_mat=wind_mat,
qs=4,
p=4,
Lewout=60e-3)
test_obj.shaft = Shaft(Drsh=test_obj.rotor.Rint * 2, Lshaft=1)
test_obj.shaft.mat_type.name = "M270_35A"
test_obj.shaft.mat_type.magnetics = None
test_obj.rotor.mat_type.name = "Load_M400"
test_obj.rotor.mat_type.magnetics = MatLamination(Wlam=0.5e-3)
test_obj.stator = LamSlotWind(
Rint=0.51,
Rext=0.8,
is_internal=False,
is_stator=True,
L1=0.95,
Nrvd=1,
Wrvd=0.05,
)
test_obj.stator.slot = SlotW10(
Zs=6,
W0=50e-3,
W1=80e-3,
W2=50e-3,
H0=15e-3,
H1=25e-3,
H2=140e-3,
H1_is_rad=False,
)
test_obj.stator.winding = WindingUD(user_wind_mat=wind_mat,
qs=4,
p=4,
Lewout=60e-3)
test_obj.stator.mat_type.name = "Param"
test_obj.stator.mat_type.magnetics = MatLamination(Wlam=0.5e-3)
BH = BHCurveParam(Bmax=1.5, mur_0=8585, mur_1=21.79, a=0.25575)
test_obj.stator.mat_type.magnetics.BH_curve = BH
test_obj.frame = Frame(Rint=0.8, Rext=0.9, Lfra=1)
test_obj.frame.mat_type.name = "M330_35A"
test_obj.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s10_1-Machine.png"))
# Rotor + Stator + 2 for frame + 1 for Shaft
self.assertEqual(len(fig.axes[0].patches), 55)
test_obj.rotor.plot()
fig = plt.gcf()
self.assertEqual(len(fig.axes[0].patches), 26)
fig.savefig(join(save_path, "test_Lam_Wind_s10_2-Rotor.png"))
# 2 for lam + Zs*4 for wind
self.assertEqual(len(fig.axes[0].patches), 26)
test_obj.stator.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s10_3-Stator.png"))
# 2 for lam + Zs*4 for wind
self.assertEqual(len(fig.axes[0].patches), 26)
def __init__(
self,
rotor=-1,
stator=-1,
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 rotor == -1:
rotor = LamSlotMag()
if stator == -1:
stator = LamSlotWind()
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", "type_machine"],
)
# 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"]
if "type_machine" in list(init_dict.keys()):
type_machine = init_dict["type_machine"]
# Initialisation by argument
# rotor can be None, a LamSlotMag object or a dict
if isinstance(rotor, dict):
self.rotor = LamSlotMag(init_dict=rotor)
else:
self.rotor = rotor
# stator can be None, a LamSlotWind 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 ["LamSlotWind", "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
# Call MachineSync init
super(MachineSIPMSM, self).__init__(
frame=frame, shaft=shaft, name=name, desc=desc, type_machine=type_machine
)
def test_Lam_Wind_27_wind_22(self):
"""Test machine plot with Slot 27 and winding rad=2, tan=2
"""
print("\nTest plot Slot 27")
plt.close("all")
test_obj = Machine()
test_obj.rotor = LamSlotWind(
Rint=0.2,
Rext=0.5,
is_internal=True,
is_stator=False,
L1=0.9,
Nrvd=2,
Wrvd=0.05,
)
test_obj.rotor.axial_vent = [
VentilationCirc(Zh=6, Alpha0=pi / 6, D0=60e-3, H0=0.35)
]
test_obj.rotor.slot = SlotW27(Zs=6,
H0=0.05,
W0=30e-3,
H1=0.125,
W1=0.06,
H2=0.05,
W2=0.09,
W3=0.04)
test_obj.rotor.mat_type.mag = MatLamination(Wlam=0.5e-3)
test_obj.rotor.winding = WindingUD(user_wind_mat=wind_mat,
qs=4,
p=4,
Lewout=60e-3)
test_obj.shaft = Shaft(Drsh=test_obj.rotor.Rint * 2, Lshaft=1)
test_obj.stator = LamSlotWind(
Rint=0.51,
Rext=0.8,
is_internal=False,
is_stator=True,
L1=0.9,
Nrvd=2,
Wrvd=0.05,
)
test_obj.stator.slot = SlotW27(Zs=18,
H0=0.05,
W0=30e-3,
H1=0.07,
W1=0.05,
H2=0.15,
W2=0.1,
W3=0.05)
test_obj.stator.winding = WindingDW2L(qs=3, p=3)
test_obj.stator.winding.Lewout = 60e-3
test_obj.stator.mat_type.mag = MatLamination(Wlam=0.5e-3)
test_obj.frame = Frame(Rint=0.8, Rext=0.9, Lfra=1)
test_obj.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s27_1-Machine.png"))
# Rotor + Stator + 2 for frame + 1 for shaft
self.assertEqual(len(fig.axes[0].patches), 73)
test_obj.rotor.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s27_2-Rotor.png"))
# 2 for lam + 4*Zs for wind + 6 vent
self.assertEqual(len(fig.axes[0].patches), 32)
test_obj.stator.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s27_3-Stator.png"))
# 2 for lam + 2*Zs for wind
self.assertEqual(len(fig.axes[0].patches), 38)
def test_Lam_Wind_21_wind_22(self):
"""Test machine plot with Slot 21 and winding rad=2, tan=2
"""
print("\nTest plot Slot 21")
plt.close("all")
test_obj = Machine()
test_obj.rotor = LamSlotWind(
Rint=0.2,
Rext=0.5,
is_internal=True,
is_stator=False,
L1=0.85,
Nrvd=3,
Wrvd=0.05,
)
test_obj.rotor.slot = SlotW21(
Zs=6,
W0=40e-3,
W1=60e-3,
W2=40e-3,
H0=20e-3,
H1=0,
H2=130e-3,
H1_is_rad=False,
)
test_obj.rotor.axial_vent.append(
VentilationTrap(Zh=6,
Alpha0=pi / 6,
W1=30e-3,
W2=60e-3,
D0=0.05,
H0=0.3))
test_obj.rotor.axial_vent.append(
VentilationTrap(Zh=6,
Alpha0=pi / 6,
W1=60e-3,
W2=90e-3,
D0=0.05,
H0=0.4))
test_obj.rotor.winding = WindingUD(user_wind_mat=wind_mat,
qs=4,
p=4,
Lewout=60e-3)
test_obj.rotor.mat_type.mag = MatLamination(Wlam=0.5e-3)
test_obj.shaft = Shaft(Drsh=test_obj.rotor.Rint * 2, Lshaft=1)
test_obj.stator = LamSlotWind(
Rint=0.51,
Rext=0.8,
is_internal=False,
is_stator=True,
L1=0.85,
Nrvd=3,
Wrvd=0.05,
)
test_obj.stator.slot = SlotW21(
Zs=18,
W0=40e-3,
W1=60e-3,
W2=90e-3,
H0=15e-3,
H1=35e-3,
H2=140e-3,
H1_is_rad=False,
)
test_obj.stator.winding = WindingDW2L(qs=3, p=3)
test_obj.stator.axial_vent.append(
VentilationCirc(Zh=12, Alpha0=pi / 6, D0=50e-3, H0=0.75))
test_obj.stator.mat_type.mag = MatLamination(Wlam=0.5e-3)
test_obj.stator.winding.Lewout = 60e-3
test_obj.frame = Frame(Rint=0.8, Rext=1, Lfra=1)
test_obj.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s21_1-Machine.png"))
# Rotor + Stator + 2 for frame + 1 for shaft
self.assertEqual(len(fig.axes[0].patches), 91)
test_obj.rotor.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s21_2-Rotor.png"))
# 2 for lam + 4*Zs for wind + 6 vents + 6 vents
self.assertEqual(len(fig.axes[0].patches), 38)
test_obj.stator.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s21_3-Stator.png"))
# 2 for lam + Zs*2 for wind + 12 vents
self.assertEqual(len(fig.axes[0].patches), 50)
tooth = test_obj.rotor.slot.get_surface_tooth()
tooth.plot(color="r")
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s21_Tooth_in.png"))
tooth = test_obj.stator.slot.get_surface_tooth()
tooth.plot(color="r")
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s21_Tooth_out.png"))
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 test_Lam_Wind_11_wind_22(self):
"""Test machine plot with Slot 11 and winding rad=2, tan=2
"""
print("\nTest plot Slot 11")
plt.close("all")
test_obj = Machine()
test_obj.rotor = LamSlotWind(
Rint=0.2,
Rext=0.5,
is_internal=True,
is_stator=False,
L1=0.9,
Nrvd=2,
Wrvd=0.05,
)
test_obj.rotor.axial_vent = [
VentilationCirc(Zh=6, Alpha0=pi / 6, D0=60e-3, H0=0.35)
]
test_obj.rotor.slot = SlotW11(
Zs=6,
W0=50e-3,
W1=60e-3,
W2=70e-3,
H0=20e-3,
H1=35e-3,
H2=130e-3,
H1_is_rad=False,
R1=10e-3,
)
test_obj.rotor.winding = WindingUD(user_wind_mat=wind_mat,
qs=4,
p=4,
Lewout=60e-3)
test_obj.rotor.mat_type.magnetics = MatLamination(Wlam=0.5e-3)
test_obj.shaft = Shaft(Drsh=test_obj.rotor.Rint * 2, Lshaft=1)
test_obj.stator = LamSlotWind(
Rint=0.51,
Rext=0.8,
is_internal=False,
is_stator=True,
L1=0.9,
Nrvd=2,
Wrvd=0.05,
)
test_obj.stator.slot = SlotW11(
Zs=18,
W0=40e-3,
W1=60e-3,
W2=90e-3,
H0=15e-3,
H1=35e-3,
H2=140e-3,
H1_is_rad=False,
R1=40e-3,
)
test_obj.stator.winding.Lewout = 60e-3
test_obj.stator.winding = WindingDW2L(qs=3, p=3)
test_obj.stator.mat_type.magnetics = MatLamination(Wlam=0.5e-3)
test_obj.frame = Frame(Rint=0.8, Rext=0.9, Lfra=1)
test_obj.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s11_1-Machine.png"))
# Rotor + Stator + 2 for frame + 1 for Shaft
self.assertEqual(len(fig.axes[0].patches), 73)
test_obj.rotor.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s11_2-Rotor.png"))
# 2 for lam + Zs*4 for wind + 6 vents
self.assertEqual(len(fig.axes[0].patches), 32)
test_obj.stator.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s11_3-Stator.png"))
# 2 for lam + Zs*2 for wind
self.assertEqual(len(fig.axes[0].patches), 38)
rotor.axial_vent.append(VentilationCirc(
Zh=8,
Alpha0=0,
D0=5e-3,
H0=40e-3
))
rotor.axial_vent.append(VentilationCirc(
Zh=8,
Alpha0=pi / 8,
D0=7e-3,
H0=40e-3
))
"""
shaft = Shaft(Drsh=rotor.Rint * 2, Lshaft=1.2)
frame = Frame(Rint=stator.Rext, Rext=stator.Rext + 10 * mm, Lfra=1)
# Set Materials
stator.mat_type = M400_50A
rotor.mat_type = M400_50A
stator.winding.conductor.cond_mat = Copper1
rotor.hole[0].magnet_0.mat_type = Magnet3
rotor.hole[0].magnet_1.mat_type = Magnet3
rotor.hole[0].magnet_0.type_magnetization = 1
rotor.hole[0].magnet_1.type_magnetization = 1
IPMSM_xxx = MachineIPMSM(name="IPMSM",
stator=stator,
rotor=rotor,
shaft=shaft,
def test_Lam_Wind_23_wind_22(self):
"""Test machine plot with Slot 23 and winding rad=2, tan=2
"""
print("\nTest plot Slot 23")
plt.close("all")
test_obj = Machine()
test_obj.rotor = LamSlotWind(
Rint=0,
Rext=0.5,
is_internal=True,
is_stator=False,
L1=0.9,
Nrvd=5,
Wrvd=0.02,
)
test_obj.rotor.slot = SlotW23(Zs=6,
W0=50e-3,
W1=90e-3,
W2=100e-3,
H0=20e-3,
H1=35e-3,
H2=130e-3)
test_obj.rotor.winding = WindingUD(user_wind_mat=wind_mat,
qs=4,
p=4,
Lewout=60e-3)
test_obj.rotor.mat_type.mag = MatLamination(Wlam=0.5e-3)
test_obj.shaft = Shaft(Drsh=test_obj.rotor.Rint * 2, Lshaft=1)
test_obj.stator = LamSlotWind(
Rint=0.51,
Rext=0.8,
is_internal=False,
is_stator=True,
L1=0.9,
Nrvd=5,
Wrvd=0.02,
)
test_obj.stator.slot = SlotW23(Zs=18,
W0=50e-3,
W1=80e-3,
W2=50e-3,
H0=15e-3,
H1=0,
H2=170e-3)
test_obj.stator.winding = WindingDW2L(qs=3, p=3)
test_obj.stator.mat_type.mag = MatLamination(Wlam=0.5e-3)
test_obj.stator.winding.Lewout = 60e-3
test_obj.frame = Frame(Rint=0.8, Rext=1, Lfra=1)
test_obj.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s23_1-Machine.png"))
# Rotor + Stator + 2 for frame + 0 shaft
self.assertEqual(len(fig.axes[0].patches), 65)
test_obj.rotor.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s23_2-Rotor.png"))
# 1 for lam + Zs*4 for wind
self.assertEqual(len(fig.axes[0].patches), 25)
test_obj.stator.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s23_3-Stator.png"))
# 2 for lam + Zs *2 for wind
self.assertEqual(len(fig.axes[0].patches), 38)
def test_Lam_Wind_14_wind_22(self):
"""Test machine plot with Slot 14 and winding rad=2, tan=2
"""
print("\nTest plot Slot 14")
plt.close("all")
test_obj = MachineDFIM()
test_obj.rotor = LamSlotWind(
Rint=0.2,
Rext=0.5,
is_internal=True,
is_stator=False,
L1=0.95,
Nrvd=1,
Wrvd=0.05,
)
test_obj.rotor.slot = SlotW14(Zs=6,
W0=100e-3,
W3=200e-3,
H0=15e-3,
H1=25e-3,
H3=140e-3)
test_obj.rotor.winding = WindingUD(user_wind_mat=wind_mat,
qs=4,
p=4,
Lewout=60e-3)
test_obj.shaft = Shaft(Drsh=test_obj.rotor.Rint * 2, Lshaft=1)
test_obj.shaft.mat_type.name = "M270_35A"
test_obj.rotor.mat_type.name = "Load_M400"
test_obj.rotor.mat_type.mag = MatMagnetics(Wlam=0.5e-3)
test_obj.stator = LamSlotWind(
Rint=0.51,
Rext=1,
is_internal=False,
is_stator=True,
L1=0.95,
Nrvd=1,
Wrvd=0.05,
)
test_obj.stator.slot = SlotW14(Zs=6,
W0=100e-3,
W3=200e-3,
H0=15e-3,
H1=25e-3,
H3=140e-3)
test_obj.stator.winding = WindingUD(user_wind_mat=wind_mat,
qs=4,
p=4,
Lewout=60e-3)
test_obj.frame = Frame(Rint=1, Rext=1.1, Lfra=1)
test_obj.frame.mat_type.name = "M330_35A"
test_obj.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s14_1-Machine.png"))
# Rotor + Stator + 2 for frame + 1 for shaft
self.assertEqual(len(fig.axes[0].patches), 55)
test_obj.rotor.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s14_2-Rotor.png"))
# 2 for lam + Zs*4 for wind
self.assertEqual(len(fig.axes[0].patches), 26)
test_obj.stator.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s14_3-Stator.png"))
# 2 for lam + Zs*4 for wind
self.assertEqual(len(fig.axes[0].patches), 26)
tooth = test_obj.rotor.slot.get_surface_tooth()
tooth.plot(color="r")
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s14_Tooth_in.png"))
tooth = test_obj.stator.slot.get_surface_tooth()
tooth.plot(color="r")
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s14_Tooth_out.png"))
def test_Lam_Mag_10_inset(self):
"""Test machine plot with Magnet 10 inset"""
plt.close("all")
test_obj = Machine()
test_obj.rotor = LamSlotMag(
Rint=40e-3,
Rext=100e-3,
is_internal=True,
is_stator=False,
L1=0.45,
Nrvd=1,
Wrvd=0.05,
)
magnet = [MagnetType10(Lmag=0.5, Hmag=0.02, Wmag=0.04)]
test_obj.rotor.slot = SlotMFlat(Zs=4, W0=0.04, H0=0.02, magnet=magnet)
test_obj.rotor.mat_type.mag = MatLamination(Wlam=0.5e-3)
test_obj.shaft = Shaft(Drsh=test_obj.rotor.Rint * 2, Lshaft=0.55)
test_obj.rotor.axial_vent.append(
VentilationCirc(Zh=4, Alpha0=0, D0=2.5e-3, H0=50e-3))
test_obj.rotor.axial_vent.append(
VentilationCirc(Zh=8, Alpha0=0, D0=5e-3, H0=60e-3))
test_obj.rotor.axial_vent.append(
VentilationCirc(Zh=12, Alpha0=0, D0=10e-3, H0=70e-3))
test_obj.stator = LamSlotMag(
Rint=110e-3,
Rext=200e-3,
is_internal=False,
is_stator=True,
L1=0.45,
Nrvd=1,
Wrvd=0.05,
)
magnet2 = [MagnetType10(Lmag=0.5, Hmag=0.02, Wmag=0.04)]
test_obj.stator.slot = SlotMFlat(Zs=8,
W0=0.04,
W3=2 * pi / 64,
H0=0.02,
magnet=magnet2)
test_obj.stator.mat_type.mag = MatLamination(Wlam=0.5e-3)
test_obj.frame = Frame(Rint=200e-3, Rext=250e-3, Lfra=0.5)
test_obj.stator.axial_vent.append(
VentilationTrap(Zh=6,
Alpha0=pi / 6,
W1=10e-3,
W2=20e-3,
D0=0.02,
H0=0.140))
test_obj.stator.axial_vent.append(
VentilationTrap(Zh=6,
Alpha0=pi / 6,
W1=20e-3,
W2=40e-3,
D0=0.02,
H0=0.170))
test_obj.plot()
fig = plt.gcf()
self.assertEqual(len(fig.axes[0].patches), 55)
fig.savefig(join(save_path, "test_Lam_Mag_10i_1-Machine.png"))
test_obj.rotor.plot()
fig = plt.gcf()
self.assertEqual(len(fig.axes[0].patches), 30)
fig.savefig(join(save_path, "test_Lam_Mag_10i_2-Rotor.png"))
test_obj.stator.plot()
fig = plt.gcf()
self.assertEqual(len(fig.axes[0].patches), 22)
fig.savefig(join(save_path, "test_Lam_Mag_10i_3-Stator.png"))
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)""",
)
test_obj.rotor.mat_type.struct.rho = 7600
test_obj.shaft = Shaft(Drsh=test_obj.rotor.Rint * 2, Lshaft=1.2)
test_obj.shaft.mat_type.struct.rho = 5000
test_obj.stator = Lamination(Rint=0.078,
Rext=0.104,
is_internal=False,
is_stator=True,
L1=0.8,
Nrvd=0,
Kf1=0.95)
test_obj.stator.axial_vent.append(
VentilationPolar(Zh=8, H0=0.08, D0=0.01, W1=pi / 8, Alpha0=pi / 8))
test_obj.stator.axial_vent.append(
VentilationPolar(Zh=8, H0=0.092, D0=0.01, W1=pi / 8, Alpha0=0))
test_obj.stator.mat_type.struct.rho = 8000
test_obj.frame = Frame(Rint=0.104, Rext=0.114, Lfra=1)
test_obj.frame.mat_type.struct.rho = 4000
M_test.append({
"test_obj": test_obj,
"Mfra": 4000 * pi * (0.114**2 - 0.104**2),
"Msha": 5000 * 1.2 * pi * 0.021**2,
})
M_test[-1]["rotor"] = {
"Slam": 1.2797e-2,
"Svent": 8 * pi * (2.5e-3**2 + 3.5e-3**2),
"Smag": 6.8e-3 * 20.6e-3 * 2 * 8,
}
M_test[-1]["rotor"]["Vlam"] = M_test[-1]["rotor"]["Slam"] * 0.7
M_test[-1]["rotor"]["Vvent"] = M_test[-1]["rotor"]["Svent"] * 0.7
M_test[-1]["rotor"]["Vmag"] = M_test[-1]["rotor"]["Smag"] * 0.4
def test_Lam_Wind_10_wind_22(self):
"""Test machine plot with Slot 10 and winding rad=2, tan=2
"""
print("\nTest plot Slot 10")
plt.close("all")
test_obj = Machine()
test_obj.rotor = LamSlotWind(
Rint=0.2,
Rext=0.5,
is_internal=True,
is_stator=False,
L1=0.95,
Nrvd=1,
Wrvd=0.05,
)
test_obj.rotor.slot = SlotW10(
Zs=6,
W0=50e-3,
W1=90e-3,
W2=100e-3,
H0=20e-3,
H1=35e-3,
H2=130e-3,
H1_is_rad=False,
)
test_obj.rotor.winding = WindingUD(
user_wind_mat=wind_mat, qs=4, p=4, Lewout=60e-3
)
test_obj.shaft = Shaft(Drsh=test_obj.rotor.Rint * 2, Lshaft=1)
test_obj.stator = LamSlotWind(
Rint=0.51,
Rext=0.8,
is_internal=False,
is_stator=True,
L1=0.95,
Nrvd=1,
Wrvd=0.05,
)
test_obj.stator.slot = SlotW10(
Zs=6,
W0=50e-3,
W1=80e-3,
W2=50e-3,
H0=15e-3,
H1=25e-3,
H2=140e-3,
H1_is_rad=False,
)
test_obj.stator.winding = WindingUD(
user_wind_mat=wind_mat, qs=4, p=4, Lewout=60e-3
)
test_obj.frame = Frame(Rint=0.8, Rext=0.9, Lfra=1)
test_obj.frame.mat_type.name = "M330_35A"
test_obj.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s10_1-Machine.png"))
# Rotor + Stator + 2 for frame + 1 for Shaft
self.assertEqual(len(fig.axes[0].patches), 55)
test_obj.rotor.plot()
fig = plt.gcf()
self.assertEqual(len(fig.axes[0].patches), 26)
fig.savefig(join(save_path, "test_Lam_Wind_s10_2-Rotor.png"))
# 2 for lam + Zs*4 for wind
self.assertEqual(len(fig.axes[0].patches), 26)
test_obj.stator.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s10_3-Stator.png"))
# 2 for lam + Zs*4 for wind
self.assertEqual(len(fig.axes[0].patches), 26)
lines = test_obj.stator.slot.build_geometry_half_tooth(is_top=False)
surf = SurfLine(line_list=lines)
surf.plot_lines()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s10_Tooth_bottom_out.png"))
lines = test_obj.stator.slot.build_geometry_half_tooth(is_top=True)
surf = SurfLine(line_list=lines)
surf.plot_lines()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s10_Tooth_top_out.png"))
lines = test_obj.rotor.slot.build_geometry_half_tooth(is_top=False)
surf = SurfLine(line_list=lines)
surf.plot_lines()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s10_Tooth_bottom_in.png"))
lines = test_obj.rotor.slot.build_geometry_half_tooth(is_top=True)
surf = SurfLine(line_list=lines)
surf.plot_lines()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s10_Tooth_top_in.png"))
tooth = test_obj.rotor.slot.get_surface_tooth()
tooth.plot(color="r")
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s10_Tooth_in.png"))
tooth = test_obj.stator.slot.get_surface_tooth()
tooth.plot(color="r")
fig = plt.gcf()
mesh_dict = tooth.comp_mesh_dict(5e-3)
for line in tooth.get_lines():
mid = line.get_middle()
plt.text(mid.real, mid.imag, str(mesh_dict[line.label]))
fig.savefig(join(save_path, "test_Lam_Wind_s10_Tooth_out.png"))
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""")
def test_Lam_Wind_12_wind_22(self):
"""Test machine plot with Slot 12 and winding rad=2, tan=2
"""
print("\nTest plot Slot 12")
plt.close("all")
test_obj = Machine()
test_obj.rotor = LamSlotWind(
Rint=0.2,
Rext=0.5,
is_internal=True,
is_stator=False,
L1=0.9,
Nrvd=2,
Wrvd=0.05,
)
test_obj.rotor.axial_vent = [
VentilationPolar(Zh=6, Alpha0=pi / 6, W1=pi / 6, D0=100e-3, H0=0.3)
]
test_obj.rotor.slot = SlotW12(Zs=6, R2=35e-3, H0=20e-3, R1=17e-3, H1=130e-3)
test_obj.rotor.winding = WindingUD(
user_wind_mat=wind_mat, qs=4, p=4, Lewout=60e-3
)
test_obj.rotor.mat_type.mag = MatLamination(Wlam=0.5e-3)
test_obj.shaft = Shaft(Drsh=test_obj.rotor.Rint * 2, Lshaft=1)
test_obj.stator = LamSlotWind(
Rint=0.51,
Rext=0.8,
is_internal=False,
is_stator=True,
L1=0.9,
Nrvd=2,
Wrvd=0.05,
)
test_obj.stator.slot = SlotW12(Zs=18, R2=25e-3, H0=30e-3, R1=0, H1=150e-3)
test_obj.stator.winding.Lewout = 60e-3
test_obj.stator.winding = WindingDW2L(qs=3, p=3)
test_obj.stator.mat_type.mag = MatLamination(Wlam=0.5e-3)
test_obj.frame = Frame(Rint=0.8, Rext=0.9, Lfra=1)
test_obj.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s12_1-Machine.png"))
# Rotor + Stator + 2 for frame + 1 for Shaft
self.assertEqual(len(fig.axes[0].patches), 73)
test_obj.rotor.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s12_2-Rotor.png"))
# 2 for lam + Zs*4 for wind + 6 vents
self.assertEqual(len(fig.axes[0].patches), 32)
test_obj.stator.plot()
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s12_3-Stator.png"))
# 2 for lam + Zs*2 for wind
self.assertEqual(len(fig.axes[0].patches), 38)
tooth = test_obj.rotor.slot.get_surface_tooth()
tooth.plot(color="r")
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s12_Tooth_in.png"))
tooth = test_obj.stator.slot.get_surface_tooth()
tooth.plot(color="r")
fig = plt.gcf()
fig.savefig(join(save_path, "test_Lam_Wind_s12_Tooth_out.png"))
