Merge pull request #493 from EOMYS-Public/MatLib

Miscellaneous Bug correction

Tests/Functions/test_save_load.py

@@ -20,10 +20,11 @@
 from pyleecan.Classes.Simu1 import Simu1
 from pyleecan.Classes.SlotM11 import SlotM11
 from pyleecan.Classes.SlotW10 import SlotW10
+from pyleecan.Classes.SlotUD import SlotUD
+from pyleecan.Classes.HoleUD import HoleUD
 from pyleecan.Classes.Winding import Winding
 from pyleecan.Classes.OPdq import OPdq
 from pyleecan.Functions.load import (
-    LoadSwitchError,
     LoadWrongDictClassError,
     LoadWrongTypeError,
     load,
@@ -247,6 +248,31 @@ def test_save_load_just_name():
     # remove(file_path)
 
 
+def test_save_load_DXF_flat():
+    """Check that you can save/load a machine with dxf slot/hole in flat mode"""
+    Prius_DXF = load(join(DATA_DIR, "Machine", "Toyota_Prius_DXF.json"))
+    save_dir = join(save_path, "Toyota_Prius_DXF")
+    # Check save
+    assert not isdir(save_dir)
+    Prius_DXF.save(save_path=save_dir, is_folder=True)
+    assert isdir(save_dir)
+    file_list = listdir(save_dir)
+    assert len(file_list) == 12
+    assert "hole.json" in file_list
+    assert "slot.json" in file_list
+    # Check load
+    Prius_2 = load(save_dir)
+    assert isinstance(Prius_2.stator.slot, SlotUD)
+    assert isinstance(Prius_2.rotor.hole[0], HoleUD)
+    assert len(Prius_DXF.compare(Prius_2)) == 0
+    # Remove file and check None
+    remove(join(save_dir, "hole.json"))
+    remove(join(save_dir, "slot.json"))
+    Prius_3 = load(save_dir)
+    assert Prius_3.stator.slot is None
+    assert Prius_3.rotor.hole[0] is None
+
+
 def test_load_error_missing():
     """Test that the load function can detect missing file"""
     with pytest.raises(LoadMissingFileError):
@@ -406,9 +432,8 @@ def test_save_load_simu(type_file):
 
 
 if __name__ == "__main__":
-    test_save_load_simu("json")
-    test_save_load_simu("h5")
-    test_save_load_simu("pkl")
-    # test_save_load_folder_path()
-    # test_save_load_json_compressed()
+    test_save_load_DXF_flat()
     print("Done")
+    # test_save_load_simu("json")
+    # test_save_load_simu("h5")
+    # test_save_load_simu("pkl")

pyleecan/Classes/BoreUD.py

@@ -200,6 +200,15 @@ def _set_line_list(self, value):
         """setter of line_list"""
         if type(value) is list:
             for ii, obj in enumerate(value):
+                if isinstance(obj, str):  # Load from file
+                    try:
+                        obj = load_init_dict(obj)[1]
+                    except Exception as e:
+                        self.get_logger().error(
+                            "Error while loading " + obj + ", setting None instead"
+                        )
+                        obj = None
+                        value[ii] = None
                 if type(obj) is dict:
                     class_obj = import_class(
                         "pyleecan.Classes", obj.get("__class__"), "line_list"

pyleecan/Classes/HoleUD.py

@@ -345,6 +345,15 @@ def _set_surf_list(self, value):
         """setter of surf_list"""
         if type(value) is list:
             for ii, obj in enumerate(value):
+                if isinstance(obj, str):  # Load from file
+                    try:
+                        obj = load_init_dict(obj)[1]
+                    except Exception as e:
+                        self.get_logger().error(
+                            "Error while loading " + obj + ", setting None instead"
+                        )
+                        obj = None
+                        value[ii] = None
                 if type(obj) is dict:
                     class_obj = import_class(
                         "pyleecan.Classes", obj.get("__class__"), "surf_list"
@@ -378,6 +387,15 @@ def _set_magnet_dict(self, value):
         """setter of magnet_dict"""
         if type(value) is dict:
             for key, obj in value.items():
+                if isinstance(obj, str):  # Load from file
+                    try:
+                        obj = load_init_dict(obj)[1]
+                    except Exception as e:
+                        self.get_logger().error(
+                            "Error while loading " + obj + ", setting None instead"
+                        )
+                        obj = None
+                        value[key] = None
                 if type(obj) is dict:
                     class_obj = import_class(
                         "pyleecan.Classes", obj.get("__class__"), "magnet_dict"

pyleecan/Classes/ImportData.py

@@ -281,6 +281,15 @@ def _set_axes(self, value):
         """setter of axes"""
         if type(value) is list:
             for ii, obj in enumerate(value):
+                if isinstance(obj, str):  # Load from file
+                    try:
+                        obj = load_init_dict(obj)[1]
+                    except Exception as e:
+                        self.get_logger().error(
+                            "Error while loading " + obj + ", setting None instead"
+                        )
+                        obj = None
+                        value[ii] = None
                 if type(obj) is dict:
                     class_obj = import_class(
                         "pyleecan.Classes", obj.get("__class__"), "axes"

pyleecan/Classes/ImportGenMatrixSin.py

@@ -220,6 +220,15 @@ def _set_sin_list(self, value):
         """setter of sin_list"""
         if type(value) is list:
             for ii, obj in enumerate(value):
+                if isinstance(obj, str):  # Load from file
+                    try:
+                        obj = load_init_dict(obj)[1]
+                    except Exception as e:
+                        self.get_logger().error(
+                            "Error while loading " + obj + ", setting None instead"
+                        )
+                        obj = None
+                        value[ii] = None
                 if type(obj) is dict:
                     class_obj = import_class(
                         "pyleecan.Classes", obj.get("__class__"), "sin_list"

pyleecan/Classes/ImportVectorField.py

@@ -211,6 +211,15 @@ def _set_components(self, value):
         """setter of components"""
         if type(value) is dict:
             for key, obj in value.items():
+                if isinstance(obj, str):  # Load from file
+                    try:
+                        obj = load_init_dict(obj)[1]
+                    except Exception as e:
+                        self.get_logger().error(
+                            "Error while loading " + obj + ", setting None instead"
+                        )
+                        obj = None
+                        value[key] = None
                 if type(obj) is dict:
                     class_obj = import_class(
                         "pyleecan.Classes", obj.get("__class__"), "components"

pyleecan/Classes/LUTdq.py

@@ -472,6 +472,15 @@ def _set_Phi_wind(self, value):
         """setter of Phi_wind"""
         if type(value) is list:
             for ii, obj in enumerate(value):
+                if isinstance(obj, str):  # Load from file
+                    try:
+                        obj = load_init_dict(obj)[1]
+                    except Exception as e:
+                        self.get_logger().error(
+                            "Error while loading " + obj + ", setting None instead"
+                        )
+                        obj = None
+                        value[ii] = None
                 if type(obj) is dict:
                     class_obj = import_class(
                         "SciDataTool.Classes", obj.get("__class__"), "Phi_wind"
@@ -499,6 +508,8 @@ def _get_Phi_dqh_interp(self):
 
     def _set_Phi_dqh_interp(self, value):
         """setter of Phi_dqh_interp"""
+        if value == -1:
+            value = RegularGridInterpolator()
         check_var("Phi_dqh_interp", value, "RegularGridInterpolator")
         self._Phi_dqh_interp = value
 

pyleecan/Classes/LamHole.py

@@ -438,6 +438,15 @@ def _set_hole(self, value):
         """setter of hole"""
         if type(value) is list:
             for ii, obj in enumerate(value):
+                if isinstance(obj, str):  # Load from file
+                    try:
+                        obj = load_init_dict(obj)[1]
+                    except Exception as e:
+                        self.get_logger().error(
+                            "Error while loading " + obj + ", setting None instead"
+                        )
+                        obj = None
+                        value[ii] = None
                 if type(obj) is dict:
                     class_obj = import_class(
                         "pyleecan.Classes", obj.get("__class__"), "hole"

pyleecan/Classes/LamSlotMulti.py

@@ -447,6 +447,15 @@ def _set_slot_list(self, value):
         """setter of slot_list"""
         if type(value) is list:
             for ii, obj in enumerate(value):
+                if isinstance(obj, str):  # Load from file
+                    try:
+                        obj = load_init_dict(obj)[1]
+                    except Exception as e:
+                        self.get_logger().error(
+                            "Error while loading " + obj + ", setting None instead"
+                        )
+                        obj = None
+                        value[ii] = None
                 if type(obj) is dict:
                     class_obj = import_class(
                         "pyleecan.Classes", obj.get("__class__"), "slot_list"

pyleecan/Classes/LamSquirrelCageMag.py

@@ -377,6 +377,15 @@ def _set_hole(self, value):
         """setter of hole"""
         if type(value) is list:
             for ii, obj in enumerate(value):
+                if isinstance(obj, str):  # Load from file
+                    try:
+                        obj = load_init_dict(obj)[1]
+                    except Exception as e:
+                        self.get_logger().error(
+                            "Error while loading " + obj + ", setting None instead"
+                        )
+                        obj = None
+                        value[ii] = None
                 if type(obj) is dict:
                     class_obj = import_class(
                         "pyleecan.Classes", obj.get("__class__"), "hole"

pyleecan/Classes/Lamination.py

@@ -1093,6 +1093,15 @@ def _set_axial_vent(self, value):
         """setter of axial_vent"""
         if type(value) is list:
             for ii, obj in enumerate(value):
+                if isinstance(obj, str):  # Load from file
+                    try:
+                        obj = load_init_dict(obj)[1]
+                    except Exception as e:
+                        self.get_logger().error(
+                            "Error while loading " + obj + ", setting None instead"
+                        )
+                        obj = None
+                        value[ii] = None
                 if type(obj) is dict:
                     class_obj = import_class(
                         "pyleecan.Classes", obj.get("__class__"), "axial_vent"
@@ -1126,6 +1135,15 @@ def _set_notch(self, value):
         """setter of notch"""
         if type(value) is list:
             for ii, obj in enumerate(value):
+                if isinstance(obj, str):  # Load from file
+                    try:
+                        obj = load_init_dict(obj)[1]
+                    except Exception as e:
+                        self.get_logger().error(
+                            "Error while loading " + obj + ", setting None instead"
+                        )
+                        obj = None
+                        value[ii] = None
                 if type(obj) is dict:
                     class_obj = import_class(
                         "pyleecan.Classes", obj.get("__class__"), "notch"
@@ -1193,6 +1211,15 @@ def _set_yoke_notch(self, value):
         """setter of yoke_notch"""
         if type(value) is list:
             for ii, obj in enumerate(value):
+                if isinstance(obj, str):  # Load from file
+                    try:
+                        obj = load_init_dict(obj)[1]
+                    except Exception as e:
+                        self.get_logger().error(
+                            "Error while loading " + obj + ", setting None instead"
+                        )
+                        obj = None
+                        value[ii] = None
                 if type(obj) is dict:
                     class_obj = import_class(
                         "pyleecan.Classes", obj.get("__class__"), "yoke_notch"

pyleecan/Classes/Loss.py

@@ -262,6 +262,15 @@ def _set_model_list(self, value):
         """setter of model_list"""
         if type(value) is list:
             for ii, obj in enumerate(value):
+                if isinstance(obj, str):  # Load from file
+                    try:
+                        obj = load_init_dict(obj)[1]
+                    except Exception as e:
+                        self.get_logger().error(
+                            "Error while loading " + obj + ", setting None instead"
+                        )
+                        obj = None
+                        value[ii] = None
                 if type(obj) is dict:
                     class_obj = import_class(
                         "pyleecan.Classes", obj.get("__class__"), "model_list"

pyleecan/Classes/MachineUD.py

@@ -259,6 +259,15 @@ def _set_lam_list(self, value):
         """setter of lam_list"""
         if type(value) is list:
             for ii, obj in enumerate(value):
+                if isinstance(obj, str):  # Load from file
+                    try:
+                        obj = load_init_dict(obj)[1]
+                    except Exception as e:
+                        self.get_logger().error(
+                            "Error while loading " + obj + ", setting None instead"
+                        )
+                        obj = None
+                        value[ii] = None
                 if type(obj) is dict:
                     class_obj = import_class(
                         "pyleecan.Classes", obj.get("__class__"), "lam_list"

pyleecan/Classes/MeshMat.py

@@ -443,6 +443,15 @@ def _set_cell(self, value):
         """setter of cell"""
         if type(value) is dict:
             for key, obj in value.items():
+                if isinstance(obj, str):  # Load from file
+                    try:
+                        obj = load_init_dict(obj)[1]
+                    except Exception as e:
+                        self.get_logger().error(
+                            "Error while loading " + obj + ", setting None instead"
+                        )
+                        obj = None
+                        value[key] = None
                 if type(obj) is dict:
                     class_obj = import_class(
                         "pyleecan.Classes", obj.get("__class__"), "cell"

pyleecan/Classes/MeshSolution.py

@@ -495,6 +495,15 @@ def _set_mesh(self, value):
         """setter of mesh"""
         if type(value) is list:
             for ii, obj in enumerate(value):
+                if isinstance(obj, str):  # Load from file
+                    try:
+                        obj = load_init_dict(obj)[1]
+                    except Exception as e:
+                        self.get_logger().error(
+                            "Error while loading " + obj + ", setting None instead"
+                        )
+                        obj = None
+                        value[ii] = None
                 if type(obj) is dict:
                     class_obj = import_class(
                         "pyleecan.Classes", obj.get("__class__"), "mesh"
@@ -546,6 +555,15 @@ def _set_solution(self, value):
         """setter of solution"""
         if type(value) is list:
             for ii, obj in enumerate(value):
+                if isinstance(obj, str):  # Load from file
+                    try:
+                        obj = load_init_dict(obj)[1]
+                    except Exception as e:
+                        self.get_logger().error(
+                            "Error while loading " + obj + ", setting None instead"
+                        )
+                        obj = None
+                        value[ii] = None
                 if type(obj) is dict:
                     class_obj = import_class(
                         "pyleecan.Classes", obj.get("__class__"), "solution"

pyleecan/Classes/MeshVTK.py

@@ -401,6 +401,8 @@ def _get_mesh(self):
 
     def _set_mesh(self, value):
         """setter of mesh"""
+        if value == -1:
+            value = vtkPointSet()
         check_var("mesh", value, "vtkPointSet")
         self._mesh = value
 
@@ -491,6 +493,8 @@ def _get_surf(self):
 
     def _set_surf(self, value):
         """setter of surf"""
+        if value == -1:
+            value = PolyData()
         check_var("surf", value, "PolyData")
         self._surf = value
 

pyleecan/Classes/OptiGenAlgNsga2Deap.py

@@ -317,6 +317,8 @@ def _get_toolbox(self):
 
     def _set_toolbox(self, value):
         """setter of toolbox"""
+        if value == -1:
+            value = Toolbox()
         check_var("toolbox", value, "Toolbox")
         self._toolbox = value