Import stackup from dictionary

_unittest/example_models/TEDB/stackup.json

@@ -0,0 +1,92 @@
+{
+  "materials": {
+    "copper": {
+      "name": "copper",
+      "conductivity": 58000000.0
+    },
+    "fr4_epoxy": {
+      "name": "fr4_epoxy",
+      "loss_tangent": 0.02,
+      "permittivity": 4.4
+    },
+    "solder_mask": {
+      "name": "solder_mask",
+      "loss_tangent": 0.035,
+      "permittivity": 3.1
+    }
+  },
+  "layers": {
+    "TOP": {
+      "name": "TOP",
+      "type": "signal",
+      "material": "copper",
+      "dielectric_fill": "copper",
+      "thickness": 5.000000000000004e-05
+    },
+    "D1": {
+      "name": "D1",
+      "type": "dielectric",
+      "material": "fr4_epoxy",
+      "thickness": 0.0001
+    },
+    "L2": {
+      "name": "L2",
+      "type": "signal",
+      "material": "copper",
+      "dielectric_fill": "copper",
+      "thickness": 3.5000000000000004e-05
+    },
+    "D2": {
+      "name": "D2",
+      "type": "dielectric",
+      "material": "fr4_epoxy",
+      "thickness": 0.0001
+    },
+    "L3": {
+      "name": "L3",
+      "type": "signal",
+      "material": "copper",
+      "dielectric_fill": "copper",
+      "thickness": 3.5000000000000004e-05
+    },
+    "D3": {
+      "name": "D3",
+      "type": "dielectric",
+      "material": "fr4_epoxy",
+      "thickness": 0.0001
+    },
+    "L4": {
+      "name": "L4",
+      "type": "signal",
+      "material": "copper",
+      "dielectric_fill": "copper",
+      "thickness": 3.5000000000000004e-05
+    },
+    "D4": {
+      "name": "D4",
+      "type": "dielectric",
+      "material": "fr4_epoxy",
+      "thickness": 0.0001
+    },
+    "L5": {
+      "name": "L5",
+      "type": "signal",
+      "material": "copper",
+      "dielectric_fill": "copper",
+      "thickness": 3.5000000000000004e-05
+    },
+    "D5": {
+      "name": "D5",
+      "type": "dielectric",
+      "material": "fr4_epoxy",
+      "thickness": 0.0001
+    },
+    "BOT": {
+      "name": "BOT",
+      "type": "signal",
+      "material": "copper",
+      "dielectric_fill": "copper",
+      "thickness": 5.000000000000004e-05
+    }
+  }
+}

_unittest/test_00_EDB.py

@@ -1,3 +1,4 @@
+import json
 import os
 
 # Setup paths for module imports
@@ -1840,6 +1841,18 @@ def test_125c_layer(self):
         assert layer.material == "copper"
         edbapp.close()
 
+    def test_125d_stackup(self):
+        fpath = os.path.join(local_path, "example_models", test_subfolder, "stackup.json")
+        stackup_json = json.load(open(fpath, "r"))
+
+        edbapp = Edb(edbversion=desktop_version)
+        edbapp.stackup.load(fpath)
+        edbapp.close()
+
+        edbapp = Edb(edbversion=desktop_version)
+        edbapp.stackup.load(stackup_json)
+        edbapp.close()
+
     def test_126_comp_def(self):
         source_path = os.path.join(local_path, "example_models", test_subfolder, "ANSYS-HSD_V1.aedb")
         target_path = os.path.join(self.local_scratch.path, "test_0126.aedb")

pyaedt/edb_core/materials.py

@@ -297,40 +297,59 @@ def _json_format(self):
 
     @pyaedt_function_handler()
     def _load(self, input_dict):
+        default_material = {
+            "name": "default",
+            "conductivity": 0,
+            "loss_tangent": 0,
+            "magnetic_loss_tangent": 0,
+            "mass_density": 0,
+            "permittivity": 1,
+            "permeability": 1,
+            "poisson_ratio": 0,
+            "specific_heat": 0,
+            "thermal_conductivity": 0,
+            "youngs_modulus": 0,
+            "thermal_expansion_coefficient": 0,
+            "dielectric_model_frequency": None,
+            "dc_permittivity": None,
+        }
         if input_dict:
-            self.conductivity = input_dict["conductivity"]
-            self.loss_tangent = input_dict["loss_tangent"]
-            self.magnetic_loss_tangent = input_dict["magnetic_loss_tangent"]
-            self.mass_density = input_dict["mass_density"]
-            self.permittivity = input_dict["permittivity"]
-            self.permeability = input_dict["permeability"]
-            self.poisson_ratio = input_dict["poisson_ratio"]
-            self.specific_heat = input_dict["specific_heat"]
-            self.thermal_conductivity = input_dict["thermal_conductivity"]
-            self.youngs_modulus = input_dict["youngs_modulus"]
-            self.thermal_expansion_coefficient = input_dict["thermal_expansion_coefficient"]
-            if input_dict["dielectric_model_frequency"] is not None:
+            for k, v in input_dict.items():
+                default_material[k] = v
+
+            self.conductivity = default_material["conductivity"]
+            self.loss_tangent = default_material["loss_tangent"]
+            self.magnetic_loss_tangent = default_material["magnetic_loss_tangent"]
+            self.mass_density = default_material["mass_density"]
+            self.permittivity = default_material["permittivity"]
+            self.permeability = default_material["permeability"]
+            self.poisson_ratio = default_material["poisson_ratio"]
+            self.specific_heat = default_material["specific_heat"]
+            self.thermal_conductivity = default_material["thermal_conductivity"]
+            self.youngs_modulus = default_material["youngs_modulus"]
+            self.thermal_expansion_coefficient = default_material["thermal_expansion_coefficient"]
+            if default_material["dielectric_model_frequency"] is not None:  # pragma: no cover
                 if self._edb_material_def.GetDielectricMaterialModel():
                     model = self._edb_material_def.GetDielectricMaterialModel()
-                    self.dielectric_model_frequency = input_dict["dielectric_model_frequency"]
-                    self.loss_tangent_at_frequency = input_dict["loss_tangent_at_frequency"]
-                    self.permittivity_at_frequency = input_dict["permittivity_at_frequency"]
-                    if input_dict["dc_permittivity"] is not None:
+                    self.dielectric_model_frequency = default_material["dielectric_model_frequency"]
+                    self.loss_tangent_at_frequency = default_material["loss_tangent_at_frequency"]
+                    self.permittivity_at_frequency = default_material["permittivity_at_frequency"]
+                    if default_material["dc_permittivity"] is not None:
                         model.SetUseDCRelativePermitivity(True)
-                        self.dc_permittivity = input_dict["dc_permittivity"]
-                    self.dc_conductivity = input_dict["dc_conductivity"]
+                        self.dc_permittivity = default_material["dc_permittivity"]
+                    self.dc_conductivity = default_material["dc_conductivity"]
                 else:
                     if not self._pclass.add_djordjevicsarkar_material(
-                        input_dict["name"],
-                        input_dict["permittivity_at_frequency"],
-                        input_dict["loss_tangent_at_frequency"],
-                        input_dict["dielectric_model_frequency"],
-                        input_dict["dc_permittivity"],
-                        input_dict["dc_conductivity"],
+                        default_material["name"],
+                        default_material["permittivity_at_frequency"],
+                        default_material["loss_tangent_at_frequency"],
+                        default_material["dielectric_model_frequency"],
+                        default_material["dc_permittivity"],
+                        default_material["dc_conductivity"],
                     ):
                         self._pclass._pedb.logger.warning(
                             'Cannot set DS model for material "{}". Check for realistic '
-                            "values that define DS Model".format(input_dict["name"])
+                            "values that define DS Model".format(default_material["name"])
                         )
             else:
                 # To unset DS model if already assigned to the material in database

pyaedt/edb_core/stackup.py

@@ -1636,50 +1636,83 @@
         temp_data = {name: area / outline_area * 100 for name, area in temp_data.items()}
         return temp_data
 
+    @pyaedt_function_handler
+    def _import_dict(self, json_dict):
+        """Import stackup from a dictionary."""
+        for k, v in json_dict.items():
+            if k == "materials":
+                for material in v.values():
+                    self._pedb.materials._load_materials(material)
+            if k == "layers":
+                if len(list(v.values())) == len(list(self.stackup_layers.values())):
+                    imported_layers_list = [l_dict["name"] for l_dict in list(v.values())]
+                    layout_layer_list = list(self.stackup_layers.keys())
+                    for layer_name in imported_layers_list:
+                        layer_index = imported_layers_list.index(layer_name)
+                        if layout_layer_list[layer_index] != layer_name:
+                            self.stackup_layers[layout_layer_list[layer_index]].name = layer_name
+                prev_layer = None
+                for layer_name, layer in v.items():
+                    if layer["name"] not in self.stackup_layers:
+                        default_layer = {
+                            "name": "default",
+                            "type": "signal",
+                            "material": "copper",
+                            "dielectric_fill": "fr4_epoxy",
+                            "thickness": 3.5000000000000004e-05,
+                            "etch_factor": 0.0,
+                            "roughness_enabled": False,
+                            "top_hallhuray_nodule_radius": 0.0,
+                            "top_hallhuray_surface_ratio": 0.0,
+                            "bottom_hallhuray_nodule_radius": 0.0,
+                            "bottom_hallhuray_surface_ratio": 0.0,
+                            "side_hallhuray_nodule_radius": 0.0,
+                            "side_hallhuray_surface_ratio": 0.0,
+                            "upper_elevation": 0.0,
+                            "lower_elevation": 0.0,
+                            "color": [242, 140, 102],
+                        }
+
+                        if not layer["type"] == "signal":
+                            default_layer["color"] = [27, 110, 76]
+
+                        for k, v in layer.items():
+                            default_layer[k] = v
+
+                        layer = default_layer
+
+                        if not prev_layer:
+                            self.add_layer(
+                                layer_name,
+                                method="add_on_top",
+                                layer_type=layer["type"],
+                                material=layer["material"],
+                                fillMaterial=layer["dielectric_fill"],
+                                thickness=layer["thickness"],
+                            )
+                            prev_layer = layer_name
+                        else:
+                            self.add_layer(
+                                layer_name,
+                                base_layer=layer_name,
+                                method="insert_below",
+                                layer_type=layer["type"],
+                                material=layer["material"],
+                                fillMaterial=layer["dielectric_fill"],
+                                thickness=layer["thickness"],
+                            )
+                            prev_layer = layer_name
+                    if layer_name in self.stackup_layers:
+                        self.stackup_layers[layer["name"]]._load_layer(layer)
+        return True
+
     @pyaedt_function_handler
     def _import_json(self, file_path):
+        """Import stackup from a json file."""
         if file_path:
             f = open(file_path)
             json_dict = json.load(f)  # pragma: no cover
-            for k, v in json_dict.items():
-                if k == "materials":
-                    for material in v.values():
-                        self._pedb.materials._load_materials(material)
-                if k == "layers":
-                    if len(list(v.values())) == len(list(self.stackup_layers.values())):
-                        imported_layers_list = [l_dict["name"] for l_dict in list(v.values())]
-                        layout_layer_list = list(self.stackup_layers.keys())
-                        for layer_name in imported_layers_list:
-                            layer_index = imported_layers_list.index(layer_name)
-                            if layout_layer_list[layer_index] != layer_name:
-                                self.stackup_layers[layout_layer_list[layer_index]].name = layer_name
-                    prev_layer = None
-                    for layer_name, layer in v.items():
-                        if layer["name"] not in self.stackup_layers:
-                            if not prev_layer:
-                                self.add_layer(
-                                    layer_name,
-                                    method="add_on_top",
-                                    layer_type=layer["type"],
-                                    material=layer["material"],
-                                    fillMaterial=layer["dielectric_fill"],
-                                    thickness=layer["thickness"],
-                                )
-                                prev_layer = layer_name
-                            else:
-                                self.add_layer(
-                                    layer_name,
-                                    base_layer=layer_name,
-                                    method="insert_below",
-                                    layer_type=layer["type"],
-                                    material=layer["material"],
-                                    fillMaterial=layer["dielectric_fill"],
-                                    thickness=layer["thickness"],
-                                )
-                                prev_layer = layer_name
-                        if layer_name in self.stackup_layers:
-                            self.stackup_layers[layer["name"]]._load_layer(layer)
-            return True
+            return self._import_dict(json_dict)
 
     @pyaedt_function_handler
     def _import_csv(self, file_path):
@@ -2092,7 +2125,9 @@
         >>> edb.stackup.load("stackup.xml")
         """
 
-        if file_path.endswith(".csv"):
+        if isinstance(file_path, dict):
+            return self._import_dict(file_path)
+        elif file_path.endswith(".csv"):
             return self._import_csv(file_path)
         elif file_path.endswith(".json"):
             return self._import_json(file_path)