[NF] adding possibility to have key in notch

Tests/GUI/Dialog/DMachineSetup/PMSlot/test_PMSlot10.py

@@ -8,7 +8,10 @@
 from Tests.GUI import gui_option  # Set unit as [m]
 from pyleecan.Classes.LamSlotMag import LamSlotMag
 from pyleecan.Classes.SlotM10 import SlotM10
+from pyleecan.Classes.Notch import Notch
 from pyleecan.GUI.Dialog.DMachineSetup.SMSlot.PMSlot10.PMSlot10 import PMSlot10
+from pyleecan.Classes.Material import Material
+from pyleecan.GUI.Dialog.DMatLib.DMatLib import MACH_KEY, LIB_KEY
 
 
 import pytest
@@ -115,6 +118,50 @@ def test_check(self):
         self.test_obj.slot = SlotM10(H0=0.10, Hmag=0.10, W0=0.10, Wmag=None)
         assert self.widget.check(self.test_obj) == "You must set Wmag !"
 
+    def test_set_Wkey(self):
+        """Check that the Widget allow to update Wkey"""
+        self.test_obj = LamSlotMag(Rint=0.1, Rext=0.2)
+        self.test_obj.slot = SlotM10(H0=0.10, W0=0.13, Wmag=0.14, Hmag=0.15)
+        self.material_dict = {LIB_KEY: list(), MACH_KEY: list()}
+        self.mat1 = Material(name="Steel1")
+        notch = Notch(self.mat1, None, None)
+        self.widget = PMSlot10(
+            self.test_obj, material_dict=self.material_dict, notch_obj=notch
+        )
+
+        self.widget.g_key.setChecked(True)
+        assert self.widget.g_key.isChecked()
+
+        # Check Unit
+        assert self.widget.unit_Wkey.text() == "[m]"
+        # Change value in GUI
+        self.widget.lf_Wkey.clear()
+        QTest.keyClicks(self.widget.lf_Wkey, "0.61")
+        self.widget.lf_Wkey.editingFinished.emit()  # To trigger the slot
+
+        assert self.widget.slot.Wmag == 0.61
+
+    def test_set_Hkey(self):
+        """Check that the Widget allow to update Hkey"""
+        self.test_obj = LamSlotMag(Rint=0.1, Rext=0.2)
+        self.test_obj.slot = SlotM10(H0=0.10, W0=0.13, Wmag=0.14, Hmag=0.15)
+        self.material_dict = {LIB_KEY: list(), MACH_KEY: list()}
+        self.mat1 = Material(name="Steel1")
+        notch = Notch(self.mat1, None, None)
+        self.widget = PMSlot10(
+            self.test_obj, material_dict=self.material_dict, notch_obj=notch
+        )
+        self.widget.g_key.setChecked(True)
+        assert self.widget.g_key.isChecked()
+        # Check Unit
+        assert self.widget.unit_Hkey.text() == "[m]"
+        # Change value in GUI
+        self.widget.lf_Hkey.clear()
+        QTest.keyClicks(self.widget.lf_Hkey, "0.61")
+        self.widget.lf_Hkey.editingFinished.emit()  # To trigger the slot
+
+        assert self.widget.slot.Hmag == 0.61
+
 
 if __name__ == "__main__":
     a = TestPMSlot10()

Tests/GUI/Dialog/DMachineSetup/PMSlot/test_PMSlot11.py

@@ -9,6 +9,9 @@
 from pyleecan.Classes.LamSlotMag import LamSlotMag
 from pyleecan.Classes.SlotM11 import SlotM11
 from pyleecan.GUI.Dialog.DMachineSetup.SMSlot.PMSlot11.PMSlot11 import PMSlot11
+from pyleecan.Classes.Notch import Notch
+from pyleecan.Classes.Material import Material
+from pyleecan.GUI.Dialog.DMatLib.DMatLib import MACH_KEY, LIB_KEY
 
 
 import pytest
@@ -192,6 +195,55 @@ def test_check(self):
         )
         assert self.widget.check(self.test_obj) is None
 
+    def test_set_Wkey(self):
+        """Check that the Widget allow to update Wkey"""
+        self.test_obj = LamSlotMag(Rint=0.1, Rext=0.2)
+        self.test_obj.slot = SlotM11(H0=0.10, W0=0.13, Wmag=0.14, Hmag=0.15)
+        self.material_dict = {LIB_KEY: list(), MACH_KEY: list()}
+        self.mat1 = Material(name="Steel1")
+        notch = Notch(self.mat1, None, None)
+        self.widget = PMSlot11(
+            self.test_obj, material_dict=self.material_dict, notch_obj=notch
+        )
+
+        self.widget.g_key.setChecked(True)
+        assert self.widget.g_key.isChecked()
+
+        self.widget.c_Wkey_unit.setCurrentIndex(0)
+        assert self.widget.c_Wkey_unit.currentText() == "rad"
+
+        self.widget.c_Wkey_unit.setCurrentIndex(1)
+        assert self.widget.c_Wkey_unit.currentText() == "deg"
+
+        self.widget.c_Wkey_unit.setCurrentIndex(0)
+        # Change value in GUI
+        self.widget.lf_Wkey.clear()
+        QTest.keyClicks(self.widget.lf_Wkey, "0.61")
+        self.widget.lf_Wkey.editingFinished.emit()  # To trigger the slot
+
+        assert self.widget.slot.Wmag == 0.61
+
+    def test_set_Hkey(self):
+        """Check that the Widget allow to update Hkey"""
+        self.test_obj = LamSlotMag(Rint=0.1, Rext=0.2)
+        self.test_obj.slot = SlotM11(H0=0.10, W0=0.13, Wmag=0.14, Hmag=0.15)
+        self.material_dict = {LIB_KEY: list(), MACH_KEY: list()}
+        self.mat1 = Material(name="Steel1")
+        notch = Notch(self.mat1, None, None)
+        self.widget = PMSlot11(
+            self.test_obj, material_dict=self.material_dict, notch_obj=notch
+        )
+        self.widget.g_key.setChecked(True)
+        assert self.widget.g_key.isChecked()
+        # Check Unit
+        assert self.widget.unit_Hkey.text() == "[m]"
+        # Change value in GUI
+        self.widget.lf_Hkey.clear()
+        QTest.keyClicks(self.widget.lf_Hkey, "0.61")
+        self.widget.lf_Hkey.editingFinished.emit()  # To trigger the slot
+
+        assert self.widget.slot.Hmag == 0.61
+
 
 if __name__ == "__main__":
     a = TestPMSlot11()

Tests/GUI/Dialog/DMachineSetup/PWSlot/test_PWSlot14.py

@@ -166,7 +166,7 @@ def test_set_wedge(self):
 
         # Add new type wedge
         self.widget.c_wedge_type.setCurrentIndex(1)
-        assert str(self.widget.c_wedge_type.currentText()) == "Normal"
+        assert str(self.widget.c_wedge_type.currentText()) == "Standard"
         assert self.test_obj.slot.wedge_type == 1
 
 

Tests/GUI/Dialog/DMachineSetup/PWSlot/test_PWSlot29.py

@@ -188,7 +188,7 @@ def test_set_wedge(self):
         assert self.test_obj.slot.wedge_mat.name == "M400-50A"
         # Add new type wedge
         self.widget.c_wedge_type.setCurrentIndex(1)
-        assert str(self.widget.c_wedge_type.currentText()) == "Normal"
+        assert str(self.widget.c_wedge_type.currentText()) == "Standard"
         assert self.test_obj.slot.wedge_type == 1
 
 

Tests/GUI/Dialog/DMachineSetup/test_notche_addition.py

@@ -111,6 +111,9 @@ def test_notch_addition(self):
         notche_wid.w_notch.lf_H0.editingFinished.emit()
         assert notche_wid.w_notch.lf_W0.value() == W0
         notche_wid.w_notch.lf_W0.editingFinished.emit()
+        # No key by default
+        assert not notche_wid.w_notch.g_key.isChecked()
+        assert notche_wid.w_notch.notch_obj.key_mat is None
         # Checking plot/preview function
         notche_wid.b_plot.clicked.emit()
         self.widget.w_step.notches_win.b_plot.clicked.emit()

Tests/Methods/Machine/test_get_polar_eq.py

@@ -23,9 +23,11 @@ def test_get_polar_eq_SCIM(self):
 
         fig = plt.gcf()
         fig.savefig(join(save_path, "test_get_polar_eq_SCIM_001.png"))
-        assert len(fig.axes[0].patches) == 227
+        # 8 Vent + 1 shaft + (2 stator + 2 rotor + 36 slot *2 layers + 28 slot * 1 layer+ 1 SCR)*2
+        assert len(fig.axes[0].patches) == 219
 
 
 if __name__ == "__main__":
     a = Test_get_polar_eq()
     a.test_get_polar_eq_SCIM()
+    print("Done")

Tests/Methods/Slot/test_HoleM58_meth.py

@@ -6,6 +6,7 @@
 import pytest
 
 from pyleecan.Classes.LamHole import LamHole
+from pyleecan.Classes.Hole import Hole
 from pyleecan.Classes.LamSlotWind import LamSlotWind
 from pyleecan.Classes.MachineIPMSM import MachineIPMSM
 from pyleecan.Classes.Magnet import Magnet
@@ -34,17 +35,84 @@
         "test_obj": test_obj,
         "S_exp": 2.917e-4,
         "SM_exp": 1.65e-4,
-        "Rmin": 0.06504,
-        "Rmax": 0.08,
+        "Rmin": 0.055,
+        "Rmax": 0.07,
         "W": 41.411e-3,
         "alpha": 0.487367,
     }
 )
 
+# For AlmostEqual
+DELTA = 1e-3
+
 
 class Test_HoleM58_meth(object):
     """Test machine plot hole 58"""
 
+    @pytest.mark.parametrize("test_dict", HoleM58_test)
+    def test_schematics(self, test_dict):
+        """Check that the schematics is correct"""
+        test_obj = test_dict["test_obj"]
+
+        point_dict = test_obj.hole[0]._comp_point_coordinate()
+        Rbo = test_obj.hole[0].get_Rbo()
+
+        # W0
+        assert abs(point_dict["Z2"] - point_dict["Z11"]) == pytest.approx(
+            test_obj.hole[0].W0
+        )
+        assert abs(point_dict["Z8"] - point_dict["Z5"]) == pytest.approx(
+            test_obj.hole[0].W0
+        )
+
+        # W1
+        assert abs(point_dict["Z12"] - point_dict["Z1"]) == pytest.approx(
+            test_obj.hole[0].W1
+        )
+        assert abs(point_dict["Z6"] - point_dict["Z7"]) == pytest.approx(
+            test_obj.hole[0].W1
+        )
+
+        # W2
+        assert abs(point_dict["Z2"] - point_dict["Z1"]) == pytest.approx(
+            test_obj.hole[0].W2
+        )
+        assert abs(point_dict["Z6"] - point_dict["Z5"]) == pytest.approx(
+            test_obj.hole[0].W2
+        )
+
+        # H2
+        assert abs(point_dict["Z2"] - point_dict["Z5"]) == pytest.approx(
+            test_obj.hole[0].H2
+        )
+        assert abs(point_dict["Z6"] - point_dict["Z1"]) == pytest.approx(
+            test_obj.hole[0].H2
+        )
+        assert abs(point_dict["Z12"] - point_dict["Z7"]) == pytest.approx(
+            test_obj.hole[0].H2
+        )
+
+        # R0
+        assert abs(point_dict["Z4"] - point_dict["Zc1"]) == pytest.approx(
+            test_obj.hole[0].R0
+        )
+        assert abs(point_dict["Z3"] - point_dict["Zc1"]) == pytest.approx(
+            test_obj.hole[0].R0
+        )
+        assert abs(point_dict["Z10"] - point_dict["Zc2"]) == pytest.approx(
+            test_obj.hole[0].R0
+        )
+        assert abs(point_dict["Z9"] - point_dict["Zc2"]) == pytest.approx(
+            test_obj.hole[0].R0
+        )
+
+        assert abs(point_dict["Zc1"]) == pytest.approx(
+            Rbo - test_obj.hole[0].R0 - test_obj.hole[0].H1
+        )
+        assert abs(point_dict["Zc2"]) == pytest.approx(
+            Rbo - test_obj.hole[0].R0 - test_obj.hole[0].H1
+        )
+
     @pytest.mark.parametrize("test_dict", HoleM58_test)
     def test_magnet_None(self, test_dict):
         """Magnet None"""
@@ -60,3 +128,36 @@ def test_magnet_Parallel(self, test_dict):
         test_obj.hole[0].magnet_0 = Magnet(type_magnetization=1)
         result = test_obj.hole[0].build_geometry()
         assert result[1].label == "Rotor_HoleMag_R0-T0-S0"
+
+    @pytest.mark.parametrize("test_dict", HoleM58_test)
+    def test_comp_radius(self, test_dict):
+        """Check that comp_radius return the correct result (analytical+num)"""
+        test_obj = test_dict["test_obj"]
+        Rmin, Rmax = test_obj.hole[0].comp_radius()
+
+        Rmax_a = test_dict["Rmax"]
+        Rmin_a = test_dict["Rmin"]
+        a, b = Rmin, Rmin_a
+        msg = f"For Rmin: Return {a} expected {b}"
+        assert abs((a - b) / a - 0) < DELTA, msg
+        a, b = Rmax, Rmax_a
+        msg = f"For Rmax: Return {a} expected {b}"
+        assert abs((a - b) / a - 0) < DELTA, msg
+
+        Rmin_a, Rmax_a = Hole.comp_radius(test_obj.hole[0])
+        a, b = Rmin, Rmin_a
+        msg = f"For Rmin: Return {a} expected {b}"
+        assert abs((a - b) / a - 0) < DELTA, msg
+
+        a, b = Rmax, Rmax_a
+        msg = f"For Rmax: Return {a} expected {b}"
+        assert abs((a - b) / a - 0) < DELTA, msg
+
+
+if __name__ == "__main__":
+    a = Test_HoleM58_meth()
+    for test_dict in HoleM58_test:
+        a.test_schematics(test_dict)
+        a.test_magnet_None(test_dict)
+        a.test_magnet_Parallel(test_dict)
+    print("Done")

Tests/Methods/Slot/test_HoleM61_meth.py

@@ -102,7 +102,7 @@
         "carac": "magnet_0",
         "Rmin_exp": 0.05984145720150872,
         "Rmax_exp": 0.11,
-        "S_exp": 0.00136534350269306,
+        "S_exp": 0.0013668826437211769,
         "SM_exp": 0.00015,
         "hasmagnet_exp": True,
     }
@@ -196,7 +196,7 @@
         "carac": "magnet_3",
         "Rmin_exp": 0.05984145720150872,
         "Rmax_exp": 0.11,
-        "S_exp": 0.00136688264372118,
+        "S_exp": 0.001365343502693063,
         "SM_exp": 0.0002,
         "hasmagnet_exp": True,
     }

Tests/Methods/Slot/test_SlotW16_meth.py

@@ -6,6 +6,8 @@
 from pyleecan.Classes.LamSlot import LamSlot
 from pyleecan.Classes.Slot import Slot
 from pyleecan.Methods.Slot.SlotW16 import S16OutterError
+import matplotlib.pyplot as plt
+from pyleecan.Classes.Arc1 import Arc1
 
 # For AlmostEqual
 DELTA = 1e-4
@@ -19,9 +21,9 @@
 slotW16_test.append(
     {
         "test_obj": lam,
-        "S_exp": 2.508259e-3,
-        "Aw": 0.6927673,
-        "SW_exp": 2.33808e-3,
+        "S_exp": 0.0029208336939601474,
+        "Aw": 0.8150115827824299,
+        "SW_exp": 0.0027506640918907002,
         "SO_exp": 0.000170169,
         "H_exp": 3.5e-2,
     }
@@ -41,6 +43,20 @@
     }
 )
 
+# Small H0/W0/R1 
+lam = LamSlot(is_internal=True, Rint=0.04, Rext=0.0746, is_stator=False)
+lam.slot = SlotW16(Zs=76, H0=0.0008, H2=0.0172, R1=1e-6, W0=0.00001, W3=0.00299)
+slotW16_test.append(
+    {
+        "test_obj": lam,
+        "S_exp": 9.278655434664112e-05,
+        "Aw": 0.08273823008510589,
+        "SW_exp": 9.278596074664111e-05,
+        "SO_exp": 5.935999999999972e-10,
+        "H_exp": 0.018,
+    }
+)
+
 
 class Test_SlotW16_meth(object):
     """pytest for SlotW16 methods"""
@@ -87,13 +103,22 @@ def test_build_geometry_active(self, test_dict):
         test_obj = test_dict["test_obj"]
         surf_list = test_obj.slot.build_geometry_active(Nrad=3, Ntan=2)
 
-        # Check label
-        assert surf_list[0].label == "Stator_Winding_R0-T0-S0"
-        assert surf_list[1].label == "Stator_Winding_R1-T0-S0"
-        assert surf_list[2].label == "Stator_Winding_R2-T0-S0"
-        assert surf_list[3].label == "Stator_Winding_R0-T1-S0"
-        assert surf_list[4].label == "Stator_Winding_R1-T1-S0"
-        assert surf_list[5].label == "Stator_Winding_R2-T1-S0"
+        if test_obj.is_stator == False:
+            # Check label
+            assert surf_list[0].label == "Rotor_Winding_R0-T0-S0"
+            assert surf_list[1].label == "Rotor_Winding_R1-T0-S0"
+            assert surf_list[2].label == "Rotor_Winding_R2-T0-S0"
+            assert surf_list[3].label == "Rotor_Winding_R0-T1-S0"
+            assert surf_list[4].label == "Rotor_Winding_R1-T1-S0"
+            assert surf_list[5].label == "Rotor_Winding_R2-T1-S0"
+        else:
+            # Check label
+            assert surf_list[0].label == "Stator_Winding_R0-T0-S0"
+            assert surf_list[1].label == "Stator_Winding_R1-T0-S0"
+            assert surf_list[2].label == "Stator_Winding_R2-T0-S0"
+            assert surf_list[3].label == "Stator_Winding_R0-T1-S0"
+            assert surf_list[4].label == "Stator_Winding_R1-T1-S0"
+            assert surf_list[5].label == "Stator_Winding_R2-T1-S0"
         # Check tangential position
         assert surf_list[0].point_ref.imag < 0
         assert surf_list[1].point_ref.imag < 0