def s_plot(self):
"""Plot the lamination (radial and axial) if possible
Parameters
----------
self : SLamParam
A SLamParam object
"""
# We use an empty lamination for the plot to avoid problem with magnet
# or winding which are not setup yet
if self.obj.Rint is None:
QMessageBox().critical(
self,
self.tr("Error"),
self.tr("Unable to plot the lamination "
"(Rint missing)"),
)
elif self.obj.Rext is None:
QMessageBox().critical(
self,
self.tr("Error"),
self.tr("Unable to plot the lamination "
"(Rext missing)"),
)
else:
plot_obj = Lamination(Rint=self.obj.Rint,
Rext=self.obj.Rext,
axial_vent=self.obj.axial_vent)
if self.obj.is_stator is not None:
plot_obj.is_stator = self.obj.is_stator
plot_obj.plot()
gcf().canvas.set_window_title(
self.tr("Lamination (without slots) Front view"))
def check(self):
"""Check that the Lamination object is correct
Parameters
----------
self :
A LamSlotWind object
Returns
-------
None
Raises
_______
LWC_SlotTooLong
The Slot is too long for the lamination (HYoke <0)
LWC_MismatchPhase
The Winding and the Converter don't have the same number of phase
LWC_OverlappingSlot
The Lamination has overlapping slot
"""
Lamination.check(self)
self.winding.conductor.check()
self.slot.check()
if self.comp_height_yoke() < 0:
raise LWC_SlotTooLong("The Slot is too long for the lamination "
"(HYoke <0)")
"""
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 comp_output(self):
"""Update the Output group according to the current value
Parameters
----------
self : WVentOut
A WVentOut object
"""
lam = self.parent().lam
# Lamination output
Rint = format(self.u.get_m(lam.Rint), ".4g")
self.out_Rint.setText(
self.tr("Lam. internal radius: ") + Rint + " " + self.u.get_m_name()
)
Rext = format(self.u.get_m(lam.Rext), ".4g")
self.out_Rext.setText(
self.tr("Lam. external radius: ") + Rext + " " + self.u.get_m_name()
)
Slam = format(self.u.get_m2(pi * (lam.Rext ** 2 - lam.Rint ** 2)), ".4g")
self.out_lam_surface.setText(
self.tr("Lam. surface (no slot, no vent): ")
+ Slam
+ " "
+ self.u.get_m2_name()
)
# Ventilation output
try:
lam = Lamination(Rext=lam.Rext, Rint=lam.Rint)
lam.axial_vent = self.parent().lam.axial_vent
Svent = format(self.u.get_m2(lam.comp_surface_axial_vent()), ".4g")
except Exception:
Svent = 0
self.out_lam_vent_surface.setText(
self.tr("Lam. surface (no slot, with vent): ?")
)
self.out_vent_surf.setText(self.tr("Vent surface: ?"))
if Svent != 0:
Slv = format(float(Slam) - float(Svent), ".4g")
self.out_lam_vent_surface.setText(
self.tr("Lam. surface (no slot, with vent): ")
+ Slv
+ " "
+ self.u.get_m2_name()
)
self.out_vent_surf.setText(
self.tr("Vent surface: ") + Svent + " " + self.u.get_m2_name()
)
def comp_masses(self):
"""Compute the Lamination masses
Parameters
----------
self : LamHole
A LamHole object
Returns
-------
M_dict: dict
Lamination mass dictionnary (Mtot, Mlam, Mmag) [kg]
"""
M_dict = Lamination.comp_masses(self)
Mmag = 0
for hole in self.hole:
if hole.has_magnet():
Mmag += hole.Zh * hole.comp_mass_magnets()
M_dict["Mmag"] = Mmag
M_dict["Mtot"] += Mmag
return M_dict
def comp_output_geo(self):
"""Compute the main geometry output
Parameters
----------
self : Lamination
A Lamination object
Returns
-------
output: OutGeoLam
Main geometry output of the lamintion
"""
output = Lamination.comp_output_geo(self)
output.Ksfill = self.comp_fill_factor()
if self.slot is None:
output.S_slot = 0
output.S_slot_wind = 0
else:
output.S_slot = self.slot.comp_surface()
output.S_slot_wind = self.slot.comp_surface_wind()
# output.S_wind_act = self.winding.conductor.comp_surface_active()
return output
def comp_surfaces(self):
"""Compute the Lamination surfaces
Parameters
----------
self : LamHole
A LamHole object
Returns
-------
S_dict: dict
Lamination surface dictionnary (Slam, Svent, Smag, Shole) [m**2]
"""
S_dict = Lamination.comp_surfaces(self)
# hole surface
Shole = 0
Smag = 0
for hole in self.hole:
Shole += hole.Zh * hole.comp_surface()
if hole.has_magnet():
Smag += hole.Zh * hole.comp_surface_magnets()
S_dict["Smag"] = Smag
S_dict["Shole"] = Shole
S_dict["Slam"] -= Shole # the magnet surface in included in the hole one
return S_dict
def comp_volumes(self):
"""Compute the Lamination volumes
Parameters
----------
self : LamHole
A LamHole object
Returns
-------
V_dict: dict
Lamination volume dictionnary (Vlam, Vvent, Vmag, Vhole) [m**3]
"""
V_dict = Lamination.comp_volumes(self)
Lt = self.comp_length()
Vhole = 0
Vmag = 0
for hole in self.hole:
Vhole += hole.Zh * hole.comp_surface() * Lt
if hole.has_magnet():
Vmag += hole.Zh * hole.comp_volume_magnets()
V_dict["Vmag"] = Vmag
V_dict["Vhole"] = Vhole
return V_dict
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 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 setUp(self):
"""Run at the begining of every test to setup the gui"""
self.test_obj = Lamination(Rint=0.1,
Rext=1,
is_stator=True,
is_internal=True)
self.test_obj.axial_vent.append(
VentilationCirc(Zh=8, H0=10e-3, D0=40e-3, Alpha0=0))
self.test_obj.axial_vent.append(
VentilationCirc(Zh=9, H0=20e-3, D0=50e-3, Alpha0=0))
self.widget = DAVDuct(self.test_obj)
def test_Lam_Mag_12_surface(self):
"""Test machine plot with Magnet 12 surface"""
plt.close("all")
rotor = LamSlotMag(
Rint=40e-3,
Rext=90e-3,
is_internal=True,
is_stator=False,
L1=0.4,
Nrvd=2,
Wrvd=0.05,
)
magnet = [MagnetType12(Lmag=0.5, Hmag=0.02, Wmag=0.06)]
rotor.slot = SlotMFlat(Zs=8, W0=0.06, magnet=magnet)
rotor.mat_type.mag = MatMagnetics(Wlam=0.5e-3)
stator = Lamination(
Rint=130e-3,
Rext=0.2,
is_internal=False,
is_stator=True,
L1=0.4,
Nrvd=2,
Wrvd=0.05,
)
stator.mat_type.mag = MatMagnetics(Wlam=0.5e-3)
rotor.plot()
fig = plt.gcf()
self.assertEqual(len(fig.axes[0].patches), 10)
fig.savefig(join(save_path, "test_Lam_Mag_12s_2-Rotor.png"))
stator.plot()
fig = plt.gcf()
self.assertEqual(len(fig.axes[0].patches), 2)
fig.savefig(join(save_path, "test_Lam_Mag_12s_3-Stator.png"))
def __init__(self, lamination):
"""Initialize the widget according the current lamination
Parameters
----------
self : DAVDuct
A DAVDuct widget
lam : Lamination
current lamination to edit
"""
# Build the interface according to the .ui file
QDialog.__init__(self)
self.setupUi(self)
self.obj = lamination # Current object
self.lam = Lamination(
init_dict=Lamination.as_dict(lamination)) # Copy to modify
# Init the GUI
if len(self.lam.axial_vent) == 0: # No vent => init circle
self.lam.axial_vent.append(VentilationCirc())
self.lam.axial_vent[0]._set_None()
self.tab_vent.clear()
for vent in self.lam.axial_vent:
self.s_add(vent)
self.tab_vent.setCurrentIndex(0)
# Set Help URL
self.b_help.url = "https://eomys.com/produits/manatee/howtos/article/"
self.b_help.url += "how-to-add-ventilation-ducts"
self.b_new.clicked.connect(self.s_add)
self.b_remove.clicked.connect(self.s_remove)
self.b_plot.clicked.connect(self.plot)
self.b_cancel.clicked.connect(self.reject)
self.b_ok.clicked.connect(self.valid_vent)
def test_Lam_Mag_14_inset(self):
"""Test machine plot with Magnet 14 inset"""
plt.close("all")
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)]
rotor.slot = SlotMPolar(Zs=4, W0=0.628, H0=0.02, magnet=magnet)
rotor.mat_type.mag = MatMagnetics(Wlam=0.5e-3)
stator = Lamination(
Rint=130e-3,
Rext=0.2,
is_internal=False,
is_stator=True,
L1=0.4,
Nrvd=5,
Wrvd=0.02,
)
stator.mat_type.mag = MatMagnetics(Wlam=0.5e-3)
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"))
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 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.mag = 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.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), 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 test_init_all_type(self):
"""Check that you can combine several kind of ventilations
"""
self.test_obj = Lamination(Rint=0.1,
Rext=1,
is_stator=True,
is_internal=True)
self.test_obj.axial_vent.append(
VentilationCirc(Zh=8, H0=10e-3, D0=40e-3, Alpha0=0))
self.test_obj.axial_vent.append(
VentilationTrap(Zh=4,
H0=24e-3,
D0=34e-3,
W1=44e-3,
W2=54e-3,
Alpha0=0))
self.test_obj.axial_vent.append(
VentilationPolar(Zh=3, H0=23e-3, D0=33e-3, W1=43e-3, Alpha0=0))
self.widget = DAVDuct(self.test_obj)
self.assertEqual(self.widget.tab_vent.count(), 3)
self.assertEqual(self.widget.tab_vent.currentIndex(), 0)
# First set
self.assertEqual(type(self.widget.tab_vent.widget(0).w_vent),
PVentCirc)
self.assertEqual(
self.widget.tab_vent.widget(0).c_vent_type.currentIndex(), 0)
self.assertEqual(
self.widget.tab_vent.widget(0).w_vent.si_Zh.value(), 8)
# 2nd set
self.assertEqual(type(self.widget.tab_vent.widget(1).w_vent),
PVentTrap)
self.assertEqual(
self.widget.tab_vent.widget(1).c_vent_type.currentIndex(), 1)
self.assertEqual(
self.widget.tab_vent.widget(1).w_vent.si_Zh.value(), 4)
# 3rd set
self.assertEqual(type(self.widget.tab_vent.widget(2).w_vent),
PVentPolar)
self.assertEqual(
self.widget.tab_vent.widget(2).c_vent_type.currentIndex(), 2)
self.assertEqual(
self.widget.tab_vent.widget(2).w_vent.si_Zh.value(), 3)
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 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(
HoleM52(Zh=8, W0=27e-3, W3=16.2e-3, H0=1e-3, H1=5e-3, H2=1e-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.09, Rext=0.12, is_internal=False, is_stator=True, L1=0.9
)
test_obj.stator.mat_type.magnetics = MatLamination(Wlam=0.5e-3)
test_obj.frame = Frame(Rint=0.12, Rext=0.12, Lfra=0.7)
self.test_obj = test_obj
def comp_surfaces(self):
"""Compute the Lamination surfaces (Lamination, Ventilation, Slot).
Parameters
----------
self : LamSlot
A LamSlot object
Returns
-------
S_dict: dict
Lamination surface dictionnary (Slam, Svent, Sslot) [m**2]
"""
S_dict = Lamination.comp_surfaces(self)
Sslot = self.slot.Zs * self.slot.comp_surface()
S_dict["Sslot"] = Sslot
S_dict["Slam"] -= Sslot
return S_dict
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()
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 draw_FEMM(
output,
is_mmfr,
is_mmfs,
sym,
is_antiper,
type_calc_leakage,
is_remove_vent=False,
is_remove_slotS=False,
is_remove_slotR=False,
is_stator_linear_BH=False,
is_rotor_linear_BH=False,
kgeo_fineness=1,
kmesh_fineness=1,
user_FEMM_dict={},
path_save="FEMM_model.fem",
is_sliding_band=True,
):
"""Draws and assigns the property of the machine in FEMM
Parameters
----------
output : Output
Output object
is_mmfr : bool
1 to compute the rotor magnetomotive force / rotor
magnetic field
is_mmfs : bool
1 to compute the stator magnetomotive force/stator
magnetic field
type_calc_leakage : int
0 no leakage calculation
1 calculation using single slot
is_remove_vent : bool
True to remove the ventilation ducts in FEMM (Default value = False)
is_remove_slotS : bool
True to solve without slot effect on the Stator (Default value = False)
is_remove_slotR : bool
True to solve without slot effect on the Rotor (Default value = False)
is_stator_linear_BH: bool
1 to use linear B(H) curve according to mur_lin, 0 to use the B(H) curve
is_rotor_linear_BH: bool
1 to use linear B(H) curve according to mur_lin, 0 to use the B(H) curve
kgeo_fineness : float
global coefficient to adjust geometry fineness
in FEMM (1: default ; > 1: finner ; < 1: less fine)
kmesh_fineness : float
global coefficient to adjust mesh fineness
in FEMM (1: default ; > 1: finner ; < 1: less fine)
sym : int
the symmetry applied on the stator and the rotor (take into account antiperiodicity)
is_antiper: bool
To apply antiperiodicity boundary conditions
Returns
-------
FEMM_dict : dict
Dictionnary containing the main parameters of FEMM (including circuits and materials)
"""
# Initialization from output for readibility
BHs = output.geo.stator.BH_curve # Stator B(H) curve
BHr = output.geo.rotor.BH_curve # Rotor B(H) curve
Is = output.elec.Is # Stator currents waveforms
Ir = output.elec.Ir # Rotor currents waveforms
machine = output.simu.machine
# Modifiy the machine to match the conditions
machine = type(machine)(init_dict=machine.as_dict())
if is_remove_slotR: # Remove all slots on the rotor
lam_dict = machine.rotor.as_dict()
machine.rotor = Lamination(init_dict=lam_dict)
if is_remove_slotS: # Remove all slots on the stator
lam_dict = machine.stator.as_dict()
machine.stator = Lamination(init_dict=lam_dict)
if is_remove_vent: # Remove all ventilations
machine.rotor.axial_vent = list()
machine.stator.axial_vent = list()
# Building geometry of the (modified) stator and the rotor
surf_list = list()
lam_ext = machine.get_lamination(is_internal=False)
lam_int = machine.get_lamination(is_internal=True)
# adding Internal Lamination surface
surf_list.extend(lam_int.build_geometry(sym=sym))
# adding the Airgap surface
if is_sliding_band:
surf_list.extend(
get_sliding_band(
sym=sym,
lam_int=output.simu.machine.get_lamination(True),
lam_ext=output.simu.machine.get_lamination(False),
)
)
else:
surf_list.extend(
get_airgap_surface(
lam_int=output.simu.machine.get_lamination(True),
lam_ext=output.simu.machine.get_lamination(False),
)
)
# adding External Lamination surface
surf_list.extend(lam_ext.build_geometry(sym=sym))
# Computing parameter (element size, arcspan...) needed to define the simulation
FEMM_dict = comp_FEMM_dict(
machine, kgeo_fineness, kmesh_fineness, type_calc_leakage
)
FEMM_dict.update(user_FEMM_dict) # Overwrite some values if needed
# The package must be initialized with the openfemm command.
femm.openfemm()
# We need to create a new Magnetostatics document to work on.
femm.newdocument(0)
# Minimize the main window for faster geometry creation.
femm.main_minimize()
# defining the problem
femm.mi_probdef(0, "meters", FEMM_dict["pbtype"], FEMM_dict["precision"])
# Creation of all the materials and circuit in FEMM
prop_dict, materials, circuits = create_FEMM_materials(
machine,
surf_list,
Is,
Ir,
BHs,
BHr,
is_mmfs,
is_mmfr,
is_stator_linear_BH,
is_rotor_linear_BH,
is_eddies,
j_t0=0,
)
create_FEMM_boundary_conditions(sym=sym, is_antiper=is_antiper)
# Draw and assign all the surfaces of the machine
for surf in surf_list:
label = surf.label
# Get the correct element size and group according to the label
mesh_dict = get_mesh_param(label, FEMM_dict)
surf.draw_FEMM(
nodeprop="None",
maxseg=FEMM_dict["arcspan"], # max span of arc element in degrees
propname="None",
elementsize=mesh_dict["element_size"],
automesh=mesh_dict["automesh"],
hide=False,
group=mesh_dict["group"],
)
assign_FEMM_surface(
surf, prop_dict[label], mesh_dict, machine.rotor, machine.stator
)
femm.mi_zoomnatural() # Zoom out
femm.mi_probdef(
FEMM_dict["freqpb"],
"meters",
FEMM_dict["pbtype"],
FEMM_dict["precision"],
FEMM_dict["Lfemm"],
FEMM_dict["minangle"],
FEMM_dict["acsolver"],
)
femm.smartmesh(FEMM_dict["smart_mesh"])
femm.mi_saveas(path_save) # Save
# femm.mi_close()
FEMM_dict["materials"] = materials
FEMM_dict["circuits"] = circuits
return FEMM_dict
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 __init__(
self,
lam_list=list(),
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,
["lam_list", "frame", "shaft", "name", "desc", "type_machine"],
)
# Overwrite default value with init_dict content
if "lam_list" in list(init_dict.keys()):
lam_list = init_dict["lam_list"]
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
# lam_list can be None or a list of Lamination object
self.lam_list = list()
if type(lam_list) is list:
for obj in lam_list:
if obj is None: # Default value
self.lam_list.append(Lamination())
elif isinstance(obj, dict):
# Check that the type is correct (including daughter)
class_name = obj.get("__class__")
if class_name not in [
"Lamination",
"LamHole",
"LamSlot",
"LamSlotMag",
"LamSlotMulti",
"LamSlotWind",
"LamSquirrelCage",
]:
raise InitUnKnowClassError(
"Unknow class name " + class_name +
" in init_dict for lam_list")
# Dynamic import to call the correct constructor
module = __import__("pyleecan.Classes." + class_name,
fromlist=[class_name])
class_obj = getattr(module, class_name)
self.lam_list.append(class_obj(init_dict=obj))
else:
self.lam_list.append(obj)
elif lam_list is None:
self.lam_list = list()
else:
self.lam_list = lam_list
# Call Machine init
super(MachineUD, self).__init__(frame=frame,
shaft=shaft,
name=name,
desc=desc,
type_machine=type_machine)
class DAVDuct(Ui_DAVDuct, QDialog):
"""Dialog to setup the ventilations
"""
def __init__(self, lamination):
"""Initialize the widget according the current lamination
Parameters
----------
self : DAVDuct
A DAVDuct widget
lam : Lamination
current lamination to edit
"""
# Build the interface according to the .ui file
QDialog.__init__(self)
self.setupUi(self)
self.obj = lamination # Current object
self.lam = Lamination(
init_dict=Lamination.as_dict(lamination)) # Copy to modify
# Init the GUI
if len(self.lam.axial_vent) == 0: # No vent => init circle
self.lam.axial_vent.append(VentilationCirc())
self.lam.axial_vent[0]._set_None()
self.tab_vent.clear()
for vent in self.lam.axial_vent:
self.s_add(vent)
self.tab_vent.setCurrentIndex(0)
# Set Help URL
self.b_help.url = "https://eomys.com/produits/manatee/howtos/article/"
self.b_help.url += "how-to-add-ventilation-ducts"
self.b_new.clicked.connect(self.s_add)
self.b_remove.clicked.connect(self.s_remove)
self.b_plot.clicked.connect(self.plot)
self.b_cancel.clicked.connect(self.reject)
self.b_ok.clicked.connect(self.valid_vent)
def s_add(self, vent=False):
"""Signal to add a new hole
Parameters
----------
self : DAVDuct
A DAVDuct widget
vent : Ventilation
The ventilation to init the GUI with
"""
# Create a new hole if needed
if type(vent) is bool:
# Default Hole is Circular
vent_obj = VentilationCirc()
vent_obj._set_None()
self.lam.axial_vent.append(vent_obj)
index = len(self.lam.axial_vent) - 1
else:
index = self.lam.axial_vent.index(vent)
tab = WVent(self.lam, index=index)
self.tab_vent.addTab(tab, "Vent " + str(index + 1))
def s_remove(self):
"""Signal to remove the last hole
Parameters
----------
self : DAVDuct
a DAVDuct object
"""
if len(self.lam.axial_vent) > 1:
self.tab_vent.removeTab(len(self.lam.axial_vent) - 1)
self.lam.axial_vent.pop(-1)
def plot(self):
"""Plot the ventilation ducts according to the table
Parameters
----------
self : DAVDuct
a DAVDuct object
"""
# We have to make sure the hole is right before trying to plot it
error = self.check()
if error: # Error => Display it
QMessageBox().critical(self, self.tr("Error"), error)
else: # No error => Plot the hole (No winding for LamSquirrelCage)
self.lam.plot()
def valid_vent(self):
"""Validate the new ventilation and update the lamination
Parameters
----------
self : DAVDuct
a DAVDuct object
"""
error = self.check()
if error: # Error => Display it
QMessageBox().critical(self, self.tr("Error"), error)
else:
self.obj.axial_vent = self.lam.axial_vent
self.accept()
def check(self):
"""Check that all the ventilation are correctly set
Parameters
----------
self : DAVDuct
a DAVDuct object
"""
for ii in range(self.tab_vent.count()):
error = self.tab_vent.widget(ii).check()
if error is not None:
return "Vent " + str(ii + 1) + ": " + error
return None
from pyleecan.Classes.Frame import Frame
from pyleecan.Classes.Shaft import Shaft
from pyleecan.Classes.ImportMatrixXls import ImportMatrixXls
from pyleecan.Classes.Material import Material
from pyleecan.Classes.MatMagnet import MatMagnet
from pyleecan.Tests.Validation.Material.M400_50A import M400_50A
from pyleecan.Tests.Validation.Material.Magnet_prius import Magnet_prius
from pyleecan.Tests.Validation.Material.Copper1 import Copper1
# Stator setup
stator = Lamination(
Rint=80.95e-3,
Rext=134.62e-3,
Nrvd=0,
L1=0.08382,
Kf1=0.95,
is_internal=False,
is_stator=True,
)
# Rotor setup
rotor = LamHole(
Rext=80.2e-3,
Rint=55.32e-3,
L1=0.08382,
Kf1=0.95,
is_internal=True,
is_stator=False,
Nrvd=0,
)
test_obj.rotor.hole[0].magnet_0.Lmag = 0.3
test_obj.rotor.hole[0].magnet_1.Lmag = 0.5
test_obj.rotor.hole[0].magnet_0.mat_type.struct.rho = 1000
test_obj.rotor.hole[0].magnet_1.mat_type.struct.rho = 1000
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.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,
