FIX: Export configuration and AEDT crash (#4913)

Co-authored-by: maxcapodi78 <Shark78>

_unittest/test_01_Design.py

@@ -379,10 +379,10 @@ def test_32_make_read_only_variable(self):
 
     def test_33_aedt_object(self):
         aedt_obj = AedtObjects()
-        assert aedt_obj.odesign
-        assert aedt_obj.oproject
+        assert aedt_obj._odesign
+        assert aedt_obj._oproject
         aedt_obj = AedtObjects(self.aedtapp._desktop_class, self.aedtapp.oproject, self.aedtapp.odesign)
-        assert aedt_obj.odesign == self.aedtapp.odesign
+        assert aedt_obj._odesign == self.aedtapp.odesign
 
     def test_34_force_project_path_disable(self):
         settings.force_error_on_missing_project = True

_unittest/test_08_Primitives3D.py

@@ -1460,6 +1460,7 @@ def test_71_create_choke(self, filename):
         self.aedtapp.delete_design(self.aedtapp.design_name)
 
     def test_72_check_choke_values(self):
+        self.aedtapp.insert_design("ChokeValues")
         choke_file1 = os.path.join(local_path, "example_models", "choke_json_file", "choke_1winding_1Layer.json")
         choke_file2 = os.path.join(local_path, "example_models", "choke_json_file", "choke_2winding_1Layer_Common.json")
         choke_file3 = os.path.join(

_unittest/test_98_Icepak.py

@@ -1022,6 +1022,7 @@ def test_52_flatten_3d_components(self):
         self.aedtapp.delete_design()
 
     def test_53_create_conduting_plate(self):
+        self.aedtapp.insert_design("conducting")
         box = self.aedtapp.modeler.create_box([0, 0, 0], [10, 20, 10], name="box1")
         self.aedtapp.modeler.create_rectangle(self.aedtapp.PLANE.XY, [0, 0, 0], [10, 20], name="surf1")
         self.aedtapp.modeler.create_rectangle(self.aedtapp.PLANE.YZ, [0, 0, 0], [10, 20], name="surf2")

pyaedt/application/Analysis.py

@@ -217,7 +217,7 @@ def materials(self):
            Materials in the project.
 
         """
-        if self._materials is None:
+        if self._materials is None and self._odesign:
             self.logger.reset_timer()
             from pyaedt.modules.MaterialLib import Materials
 
@@ -281,7 +281,9 @@ def Position(self):
             Position object.
 
         """
-        return self.modeler.Position
+        if self.modeler:
+            return self.modeler.Position
+        return
 
     @property
     def available_variations(self):

pyaedt/application/Analysis3D.py

@@ -148,7 +148,7 @@ def modeler(self):
         :class:`pyaedt.modeler.modeler3d.Modeler3D` or :class:`pyaedt.modeler.modeler2d.Modeler2D`
             Modeler object.
         """
-        if self._modeler is None:
+        if self._modeler is None and self._odesign:
             self.logger.reset_timer()
 
             from pyaedt.modeler.modeler2d import Modeler2D
@@ -167,7 +167,7 @@ def mesh(self):
         :class:`pyaedt.modules.Mesh.Mesh` or :class:`pyaedt.modules.MeshIcepak.IcepakMesh`
             Mesh object.
         """
-        if self._mesh is None:
+        if self._mesh is None and self._odesign:
             self.logger.reset_timer()
 
             from pyaedt.modules.Mesh import Mesh
@@ -187,7 +187,7 @@ def post(self):
         :class:`pyaedt.modules.AdvancedPostProcessing.PostProcessor`
             PostProcessor object.
         """
-        if self._post is None:
+        if self._post is None and self._odesign:
             self.logger.reset_timer()
             if is_ironpython:  # pragma: no cover
                 from pyaedt.modules.PostProcessor import PostProcessor

pyaedt/application/Analysis3DLayout.py

@@ -151,7 +151,7 @@ def post(self):
         :class:`pyaedt.modules.AdvancedPostProcessing.PostProcessor`
             PostProcessor object.
         """
-        if self._post is None:
+        if self._post is None and self._odesign:
             self.logger.reset_timer()
             if is_ironpython:  # pragma: no cover
                 from pyaedt.modules.PostProcessor import PostProcessor
@@ -170,7 +170,7 @@ def mesh(self):
         -------
         :class:`pyaedt.modules.Mesh3DLayout.Mesh3d`
         """
-        if self._mesh is None:
+        if self._mesh is None and self._odesign:
             from pyaedt.modules.Mesh3DLayout import Mesh3d
 
             self._mesh = Mesh3d(self)
@@ -249,7 +249,7 @@ def modeler(self):
         -------
         :class:`pyaedt.modeler.modelerpcb.Modeler3DLayout`
         """
-        if self._modeler is None:
+        if self._modeler is None and self._odesign:
             self.logger.reset_timer()
             from pyaedt.modeler.modelerpcb import Modeler3DLayout
 

pyaedt/application/AnalysisMaxwellCircuit.py

@@ -111,7 +111,7 @@ def modeler(self):
         -------
         :class:`pyaedt.modeler.schematic.ModelerMaxwellCircuit`
         """
-        if self._modeler is None:
+        if self._modeler is None and self._odesign:
             from pyaedt.modeler.schematic import ModelerMaxwellCircuit
 
             self._modeler = ModelerMaxwellCircuit(self)

pyaedt/application/AnalysisNexxim.py

@@ -180,7 +180,7 @@ def post(self):
         :class:`pyaedt.modules.AdvancedPostProcessing.CircuitPostProcessor`
             PostProcessor object.
         """
-        if self._post is None:
+        if self._post is None and self._odesign:
             self.logger.reset_timer()
             from pyaedt.modules.PostProcessor import CircuitPostProcessor
 
@@ -221,7 +221,7 @@ def nominal_sweep(self):
     @property
     def modeler(self):
         """Modeler object."""
-        if self._modeler is None:
+        if self._modeler is None and self._odesign:
             self.logger.reset_timer()
             from pyaedt.modeler.schematic import ModelerNexxim
 

pyaedt/application/AnalysisRMxprt.py

@@ -89,7 +89,7 @@ def post(self):
         -------
         :class:`pyaedt.modules.PostProcessor.CircuitPostProcessor`
         """
-        if self._post is None:  # pragma: no cover
+        if self._post is None and self._odesign:  # pragma: no cover
             self.logger.reset_timer()
             from pyaedt.modules.PostProcessor import CircuitPostProcessor
 
@@ -107,7 +107,7 @@ def modeler(self):
         :class:`pyaedt.modules.modeler2d.ModelerRMxprt`
 
         """
-        if self._modeler is None:
+        if self._modeler is None and self._odesign:
             from pyaedt.modeler.modeler2d import ModelerRMxprt
 
             self._modeler = ModelerRMxprt(self)

pyaedt/application/AnalysisTwinBuilder.py

@@ -123,7 +123,7 @@ def modeler(self):
         -------
         :class:`pyaedt.modeler.schematic.ModelerTwinBuilder`
         """
-        if self._modeler is None:
+        if self._modeler is None and self._odesign:
             from pyaedt.modeler.schematic import ModelerTwinBuilder
 
             self._modeler = ModelerTwinBuilder(self)
@@ -137,7 +137,7 @@ def post(self):
         -------
         :class:`pyaedt.modules.PostProcessor.CircuitPostProcessor`
         """
-        if self._post is None:  # pragma: no cover
+        if self._post is None and self._odesign:  # pragma: no cover
             self.logger.reset_timer()
             from pyaedt.modules.PostProcessor import CircuitPostProcessor
 

pyaedt/application/Design.py

@@ -3265,9 +3265,12 @@ def close_project(self, name=None, save=True):
                 self._init_variables()
             self._oproject = None
             self._odesign = None
+            self.logger.odesign = None
+            self.logger.oproject = None
+            self.design_solutions._odesign = None
+            AedtObjects.__init__(self, self._desktop_class, is_inherithed=True)
         else:
             self.desktop_class.active_project(legacy_name)
-        AedtObjects.__init__(self, self._desktop_class, is_inherithed=True)
 
         i = 0
         timeout = 10
@@ -3323,11 +3326,17 @@ def delete_design(self, name=None, fallback_design=None):
                 if is_windows:
                     self._init_variables()
                 self._odesign = None
+                self.logger.odesign = None
+                self.design_solutions._odesign = None
+                AedtObjects.__init__(self, self._desktop_class, project=self.oproject, is_inherithed=True)
                 return False
         else:
             if is_windows:
                 self._init_variables()
             self._odesign = None
+            self.logger.odesign = None
+            self.design_solutions._odesign = None
+            AedtObjects.__init__(self, self._desktop_class, project=self.oproject, is_inherithed=True)
         return True
 
     @pyaedt_function_handler(separator_name="name")
@@ -4167,11 +4176,15 @@ class DesignSettings:
     def __init__(self, app):
         self._app = app
         self.manipulate_inputs = None
+
+    @property
+    def design_settings(self):
+        """Design settings."""
         try:
-            self.design_settings = self._app.odesign.GetChildObject("Design Settings")
+            return self._app.odesign.GetChildObject("Design Settings")
         except GrpcApiError:  # pragma: no cover
             self._app.logger.error("Failed to retrieve design settings.")
-            self.design_settings = None
+            return None
 
     @property
     def available_properties(self):

pyaedt/application/aedt_objects.py

@@ -33,6 +33,8 @@
 
 class AedtObjects(object):
     def __init__(self, desktop=None, project=None, design=None, is_inherithed=False):
+        self._odesign = design
+        self._oproject = project
         if desktop:
             self._odesktop = desktop.odesktop
         elif _desktop_sessions and project:
@@ -48,15 +50,14 @@ def __init__(self, desktop=None, project=None, design=None, is_inherithed=False)
 
         if not is_inherithed:
             if project:
-                self.oproject = project
                 if design:
-                    self.odesign = design
+                    self._odesign = design
                 else:
-                    self.odesign = self.oproject.GetActiveDesign()
+                    self._odesign = self._oproject.GetActiveDesign()
             else:
-                self.oproject = self._odesktop.GetActiveProject()
-                if self.oproject:
-                    self.odesign = self.oproject.GetActiveDesign()
+                self._oproject = self._odesktop.GetActiveProject()
+                if self._oproject:
+                    self._odesign = self._oproject.GetActiveDesign()
         self._oboundary = None
         self._oimport_export = None
         self._ooptimetrics = None
@@ -90,16 +91,16 @@ def oradfield(self):
 
         >>> oDesign.GetModule("RadField")
         """
-        if self.design_type == "HFSS" and self.odesign.GetSolutionType() not in ["EigenMode", "Characteristic Mode"]:
-            return self.odesign.GetModule("RadField")
+        if self.design_type == "HFSS" and self._odesign.GetSolutionType() not in ["EigenMode", "Characteristic Mode"]:
+            return self._odesign.GetModule("RadField")
         return None
 
     @pyaedt_function_handler()
     def get_module(self, module_name):
         """Aedt Module object."""
-        if self.design_type not in ["EMIT"] and self.odesign:
+        if self.design_type not in ["EMIT"] and self._odesign:
             try:
-                return self.odesign.GetModule(module_name)
+                return self._odesign.GetModule(module_name)
             except Exception:
                 return None
         return None
@@ -113,7 +114,9 @@ def o_symbol_manager(self):
 
         >>> oSymbolManager = oDefinitionManager.GetManager("Symbol")
         """
-        return self.odefinition_manager.GetManager("Symbol")
+        if self.odefinition_manager:
+            return self.odefinition_manager.GetManager("Symbol")
+        return
 
     @property
     def opadstackmanager(self):
@@ -124,13 +127,13 @@ def opadstackmanager(self):
 
         >>> oPadstackManger = oDefinitionManager.GetManager("Padstack")
         """
-        if not self._opadstackmanager:
-            self._opadstackmanager = self.oproject.GetDefinitionManager().GetManager("Padstack")
+        if self._oproject and not self._opadstackmanager:
+            self._opadstackmanager = self._oproject.GetDefinitionManager().GetManager("Padstack")
         return self._opadstackmanager
 
     @property
     def design_type(self):
-        return self.odesign.GetDesignType()
+        return self._odesign.GetDesignType()
 
     @property
     def oboundary(self):
@@ -215,8 +218,8 @@ def odefinition_manager(self):
 
         >>> oDefinitionManager = oProject.GetDefinitionManager()
         """
-        if not self._odefinition_manager:
-            self._odefinition_manager = self.oproject.GetDefinitionManager()
+        if not self._odefinition_manager and self._oproject:
+            self._odefinition_manager = self._oproject.GetDefinitionManager()
         return self._odefinition_manager
 
     @property
@@ -228,9 +231,8 @@ def omaterial_manager(self):
 
         >>> oMaterialManager = oDefinitionManager.GetManager("Material")
         """
-        if not self._omaterial_manager:
-            if self.odefinition_manager:
-                self._omaterial_manager = self.odefinition_manager.GetManager("Material")
+        if self.odefinition_manager and not self._omaterial_manager:
+            self._omaterial_manager = self.odefinition_manager.GetManager("Material")
         return self._omaterial_manager
 
     @property
@@ -247,7 +249,7 @@ def omodelsetup(self):
         if not self._omodel_setup:
             if (
                 self.design_type in ["Maxwell 3D", "Maxwell 2D"]
-                and self.odesign.GetSolutionType() == "Transient"
+                and self._odesign.GetSolutionType() == "Transient"
                 or self.design_type == "HFSS"
             ):
                 self._omodel_setup = self.get_module("ModelSetup")
@@ -262,7 +264,7 @@ def o_maxwell_parameters(self):
 
         >>> oDesign.GetModule("MaxwellParameterSetup")
         """
-        if self.design_type not in ["Maxwell 3D", "Maxwell 2D"]:
+        if self._odesign and self.design_type not in ["Maxwell 3D", "Maxwell 2D"]:
             return
         if not self._o_maxwell_parameters:
             self._o_maxwell_parameters = self.get_module("MaxwellParameterSetup")
@@ -271,7 +273,7 @@ def o_maxwell_parameters(self):
     @property
     def omonitor(self):
         """AEDT Monitor Object."""
-        if not self.design_type == "Icepak":
+        if not self._odesign or not self.design_type == "Icepak":
             return
         if not self._omonitor:
             self._omonitor = self.get_module("Monitor")
@@ -395,18 +397,18 @@ def oeditor(self):
         ----------
 
         >>> oEditor = oDesign.SetActiveEditor("SchematicEditor")"""
-        if not self._oeditor:
+        if not self._oeditor and self._odesign:
             if self.design_type in ["Circuit Design", "Twin Builder", "Maxwell Circuit", "EMIT"]:
-                self._oeditor = self.odesign.SetActiveEditor("SchematicEditor")
+                self._oeditor = self._odesign.SetActiveEditor("SchematicEditor")
                 if is_linux and settings.aedt_version == "2024.1":
                     time.sleep(1)
                     self._odesktop.CloseAllWindows()
             elif self.design_type in ["HFSS 3D Layout Design", "HFSS3DLayout"]:
-                self._oeditor = self.odesign.SetActiveEditor("Layout")
+                self._oeditor = self._odesign.SetActiveEditor("Layout")
             elif self.design_type in ["RMxprt", "RMxprtSolution"]:
-                self._oeditor = self.odesign.SetActiveEditor("Machine")
+                self._oeditor = self._odesign.SetActiveEditor("Machine")
             else:
-                self._oeditor = self.odesign.SetActiveEditor("3D Modeler")
+                self._oeditor = self._odesign.SetActiveEditor("3D Modeler")
         return self._oeditor
 
     @property
@@ -419,19 +421,19 @@ def layouteditor(self):
         >>> oDesign.SetActiveEditor("Layout")
         """
         if not self._layouteditor and self.design_type in ["Circuit Design"]:
-            self._layouteditor = self.odesign.SetActiveEditor("Layout")
+            self._layouteditor = self._odesign.SetActiveEditor("Layout")
         return self._layouteditor
 
     @property
     def o_component_manager(self):
         """Component manager object."""
-        if not self._o_component_manager:
+        if not self._o_component_manager and self.odefinition_manager:
             self._o_component_manager = self.odefinition_manager.GetManager("Component")
         return self._o_component_manager
 
     @property
     def o_model_manager(self):
         """Model manager object."""
-        if not self._o_model_manager:
+        if not self._o_model_manager and self.odefinition_manager:
             self._o_model_manager = self.odefinition_manager.GetManager("Model")
         return self._o_model_manager