pyedb 0.28.0__py3-none-any.whl → 0.30.0__py3-none-any.whl

pyedb/configuration/cfg_s_parameter_models.py

@@ -24,37 +24,93 @@ from pathlib import Path
 
 
 class CfgSParameterModel:
-    def __init__(self, pdata, path_lib, sparam_dict):
-        self._pedb = pdata._pedb
+    def __init__(self, **kwargs):
+        self.name = kwargs.get("name", "")
+        self.component_definition = kwargs.get("component_definition", "")
+        self.file_path = kwargs.get("file_path", "")
+        self.apply_to_all = kwargs.get("apply_to_all", False)
+        self.components = kwargs.get("components", [])
+        self.reference_net = kwargs.get("reference_net", "")
+        self.reference_net_per_component = kwargs.get("reference_net_per_component", {})
+        self.pin_order = kwargs.get("pin_order", None)
+
+
+class CfgSParameters:
+    def __init__(self, pedb, data, path_lib=None):
+        self._pedb = pedb
         self.path_libraries = path_lib
-        self._sparam_dict = sparam_dict
-        self.name = self._sparam_dict.get("name", "")
-        self.component_definition = self._sparam_dict.get("component_definition", "")
-        self.file_path = self._sparam_dict.get("file_path", "")
-        self.apply_to_all = self._sparam_dict.get("apply_to_all", False)
-        self.components = self._sparam_dict.get("components", [])
-        self.reference_net = self._sparam_dict.get("reference_net", "")
-        self.reference_net_per_component = self._sparam_dict.get("reference_net_per_component", {})
+        self.s_parameters_models = [CfgSParameterModel(**i) for i in data]
 
     def apply(self):
-        fpath = self.file_path
-        if not Path(fpath).anchor:
-            fpath = str(Path(self.path_libraries) / fpath)
-        comp_def = self._pedb.definitions.component[self.component_definition]
-        comp_def.add_n_port_model(fpath, self.name)
-        comp_list = dict()
-        if self.apply_to_all:
-            comp_list.update(
-                {refdes: comp for refdes, comp in comp_def.components.items() if refdes not in self.components}
-            )
-        else:
-            comp_list.update(
-                {refdes: comp for refdes, comp in comp_def.components.items() if refdes in self.components}
-            )
+        for s_param in self.s_parameters_models:
+            fpath = s_param.file_path
+            if not Path(fpath).anchor:
+                fpath = str(Path(self.path_libraries) / fpath)
+            comp_def = self._pedb.definitions.component[s_param.component_definition]
+            if s_param.pin_order:
+                comp_def.set_properties(pin_order=s_param.pin_order)
+            comp_def.add_n_port_model(fpath, s_param.name)
+            comp_list = dict()
+            if s_param.apply_to_all:
+                comp_list.update(
+                    {refdes: comp for refdes, comp in comp_def.components.items() if refdes not in s_param.components}
+                )
+            else:
+                comp_list.update(
+                    {refdes: comp for refdes, comp in comp_def.components.items() if refdes in s_param.components}
+                )
 
-        for refdes, comp in comp_list.items():
-            if refdes in self.reference_net_per_component:
-                ref_net = self.reference_net_per_component[refdes]
+            for refdes, comp in comp_list.items():
+                if refdes in s_param.reference_net_per_component:
+                    ref_net = s_param.reference_net_per_component[refdes]
+                else:
+                    ref_net = s_param.reference_net
+                comp.use_s_parameter_model(s_param.name, reference_net=ref_net)
+
+    def get_data_from_db(self):
+        db_comp_def = self._pedb.definitions.component
+        for name, compdef_obj in db_comp_def.items():
+            nport_models = compdef_obj.component_models
+            if not nport_models:
+                continue
             else:
-                ref_net = self.reference_net
-            comp.use_s_parameter_model(self.name, reference_net=ref_net)
+                pin_order = compdef_obj.get_properties()["pin_order"]
+                temp_comps = compdef_obj.components
+                for model_name, model_obj in nport_models.items():
+                    temp_comp_list = []
+                    reference_net_per_component = {}
+                    for i in temp_comps.values():
+                        s_param_model = i.model_properties.get("s_parameter_model")
+                        if s_param_model:
+                            if s_param_model["model_name"] == model_name:
+                                temp_comp_list.append(i.refdes)
+                                reference_net_per_component[i.refdes] = s_param_model["reference_net"]
+                        else:
+                            continue
+
+                    self.s_parameters_models.append(
+                        CfgSParameterModel(
+                            name=model_name,
+                            component_definition=name,
+                            file_path=model_obj.reference_file,
+                            apply_to_all=False,
+                            components=temp_comp_list,
+                            reference_net_per_component=reference_net_per_component,
+                            pin_order=pin_order,
+                        )
+                    )
+
+        data = []
+        for i in self.s_parameters_models:
+            data.append(
+                {
+                    "name": i.name,
+                    "component_definition": i.component_definition,
+                    "file_path": i.file_path,
+                    "apply_to_all": i.apply_to_all,
+                    "components": i.components,
+                    "reference_net_per_component": i.reference_net_per_component,
+                    "pin_order": i.pin_order,
+                }
+            )
+        return data

pyedb/configuration/cfg_setup.py

@@ -177,6 +177,11 @@ class CfgSetups:
     def get_data_from_db(self):
         setups = []
         for _, s in self._pedb.setups.items():
+            if float(self._pedb.edbversion) < 2025.1:
+                if not s.type == "hfss":
+                    self._pedb.logger.warning("Only HFSS setups are exported in 2024 R2 and earlier version.")
+                    continue
+
             stp = {}
             if s.type == "hfss":
                 for p_name in CfgHFSSSetup(self._pedb).__dict__:

pyedb/configuration/cfg_stackup.py

@@ -44,6 +44,7 @@ class CfgLayer(CfgBase):
         self.material = kwargs.get("material", None)
         self.fill_material = kwargs.get("fill_material", None)
         self.thickness = kwargs.get("thickness", None)
+        self.roughness = kwargs.get("roughness", None)
 
 
 class CfgStackup:
@@ -139,12 +140,7 @@ class CfgStackup:
     def get_layers_from_db(self):
         layers = []
         for name, obj in self._pedb.stackup.all_layers.items():
-            layer = {}
-            for p_name in CfgLayer().__dict__:
-                p_value = getattr(obj, p_name, None)
-                if p_value is not None:
-                    layer[p_name] = getattr(obj, p_name)
-            layers.append(layer)
+            layers.append(obj.properties)
         return layers
 
     def get_data_from_db(self):

pyedb/configuration/configuration.py

@@ -106,6 +106,9 @@ class Configuration:
     def run(self, **kwargs):
         """Apply configuration settings to the current design"""
 
+        if self.cfg_data.general:
+            self.cfg_data.general.apply()
+
         # Configure boundary settings
         if self.cfg_data.boundaries:
             self.cfg_data.boundaries.apply()
@@ -117,10 +120,6 @@ class Configuration:
         # Configure components
         self.cfg_data.components.apply()
 
-        # Configure padstacks
-        if self.cfg_data.padstacks:
-            self.cfg_data.padstacks.apply()
-
         # Configure pin groups
         self.cfg_data.pin_groups.apply()
 
@@ -145,9 +144,12 @@ class Configuration:
         else:
             self.cfg_data.stackup.apply()
 
+        # Configure padstacks
+        if self.cfg_data.padstacks:
+            self.cfg_data.padstacks.apply()
+
         # Configure S-parameter
-        for s_parameter_model in self.cfg_data.s_parameters:
-            s_parameter_model.apply()
+        self.cfg_data.s_parameters.apply()
 
         # Configure SPICE models
         for spice_model in self.cfg_data.spice_models:
@@ -273,6 +275,8 @@ class Configuration:
         """
         self._pedb.logger.info("Getting data from layout database.")
         data = {}
+        if kwargs.get("general", False):
+            data["general"] = self.cfg_data.general.get_data_from_db()
         if kwargs.get("stackup", False):
             data["stackup"] = self.cfg_data.stackup.get_data_from_db()
         if kwargs.get("package_definitions", False):
@@ -293,6 +297,10 @@ class Configuration:
             data["operations"] = self.cfg_data.operations.get_data_from_db()
         if kwargs.get("padstacks", False):
             data["padstacks"] = self.cfg_data.padstacks.get_data_from_db()
+        if kwargs.get("s_parameters", False):
+            data["s_parameters"] = self.cfg_data.s_parameters.get_data_from_db()
+        if kwargs.get("boundaries", False):
+            data["boundaries"] = self.cfg_data.boundaries.get_data_from_db()
 
         return data
 
@@ -307,6 +315,11 @@ class Configuration:
         nets=True,
         pin_groups=True,
         operations=True,
+        components=True,
+        boundaries=True,
+        s_parameters=True,
+        padstacks=True,
+        general=True,
     ):
         """Export the configuration data from layout to a file.
 
@@ -330,12 +343,20 @@ class Configuration:
             Whether to export pin groups.
         operations : bool
             Whether to export operations.
+        components : bool
+            Whether to export component.
+        boundaries : bool
+            Whether to export boundaries.
+        s_parameters : bool
+            Whether to export s_parameters.
+        padstacks : bool
+            Whether to export padstacks.
+        general : bool
+            Whether to export general information.
         Returns
         -------
         bool
         """
-        file_path = file_path if isinstance(file_path, Path) else Path(file_path)
-        file_path = file_path if file_path.suffix == ".json" else file_path.with_suffix(".json")
         data = self.get_data_from_db(
             stackup=stackup,
             package_definitions=package_definitions,
@@ -345,7 +366,19 @@ class Configuration:
             nets=nets,
             pin_groups=pin_groups,
             operations=operations,
+            components=components,
+            boundaries=boundaries,
+            s_parameters=s_parameters,
+            padstacks=padstacks,
+            general=general,
         )
+
+        file_path = file_path if isinstance(file_path, Path) else Path(file_path)
+        file_path = file_path.with_suffix(".json") if file_path.suffix == "" else file_path
+
         with open(file_path, "w") as f:
-            json.dump(data, f, ensure_ascii=False, indent=4)
+            if file_path.suffix == ".json":
+                json.dump(data, f, ensure_ascii=False, indent=4)
+            else:
+                toml.dump(data, f)
         return True if os.path.isfile(file_path) else False

pyedb/dotnet/edb.py

@@ -558,6 +558,10 @@ class Edb(Database):
             for cell in list(self.top_circuit_cells):
                 if cell.GetName() == self.cellname:
                     self._active_cell = cell
+        if self._active_cell is None:
+            for cell in list(self.circuit_cells):
+                if cell.GetName() == self.cellname:
+                    self._active_cell = cell
         # if self._active_cell is still None, set it to default cell
         if self._active_cell is None:
             self._active_cell = list(self.top_circuit_cells)[0]
@@ -1455,12 +1459,12 @@ class Edb(Database):
     def import_gds_file(
         self,
         inputGDS,
-        WorkDir=None,
         anstranslator_full_path="",
         use_ppe=False,
         control_file=None,
         tech_file=None,
         map_file=None,
+        layer_filter=None,
     ):
         """Import a GDS file and generate an ``edb.def`` file in the working directory.
 
@@ -1471,10 +1475,6 @@ class Edb(Database):
         ----------
         inputGDS : str
             Full path to the GDS file.
-        WorkDir : str, optional
-            Directory in which to create the ``aedb`` folder. The default value is ``None``,
-            in which case the AEDB file is given the same name as the GDS file. Only the extension
-            differs.
         anstranslator_full_path : str, optional
             Full path to the Ansys translator.
         use_ppe : bool, optional
@@ -1484,31 +1484,67 @@ class Edb(Database):
             the XML file in the same directory as the GDS file. To succeed, the XML file and GDS file must
             have the same name. Only the extension differs.
         tech_file : str, optional
-            Technology file. It uses Helic to convert tech file to xml and then imports the gds. Works on Linux only.
+            Technology file. For versions<2024.1 it uses Helic to convert tech file to xml and then imports
+            the gds. Works on Linux only.
+            For versions>=2024.1 it can directly parse through supported foundry tech files.
         map_file : str, optional
             Layer map file.
-
-        Returns
-        -------
-        bool
-            ``True`` when successful, ``False`` when failed.
+        layer_filter:str,optional
+            Layer filter file.
 
         """
-        if not is_linux and tech_file:
-            self.logger.error("Technology files are supported only in Linux. Use control file instead.")
-            return False
         control_file_temp = os.path.join(tempfile.gettempdir(), os.path.split(inputGDS)[-1][:-3] + "xml")
-        ControlFile(xml_input=control_file, tecnhology=tech_file, layer_map=map_file).write_xml(control_file_temp)
-        if self.import_layout_pcb(
-            inputGDS,
-            working_dir=WorkDir,
-            anstranslator_full_path=anstranslator_full_path,
-            use_ppe=use_ppe,
-            control_file=control_file_temp,
-        ):
-            return True
+        if float(self.edbversion) < 2024.1:
+            if not is_linux and tech_file:
+                self.logger.error("Technology files are supported only in Linux. Use control file instead.")
+                return False
+
+            ControlFile(xml_input=control_file, tecnhology=tech_file, layer_map=map_file).write_xml(control_file_temp)
+            if self.import_layout_pcb(
+                inputGDS,
+                anstranslator_full_path=anstranslator_full_path,
+                use_ppe=use_ppe,
+                control_file=control_file_temp,
+            ):
+                return True
+            else:
+                return False
         else:
-            return False
+            temp_map_file = os.path.splitext(inputGDS)[0] + ".map"
+            temp_layermap_file = os.path.splitext(inputGDS)[0] + ".layermap"
+
+            if map_file is None:
+                if os.path.isfile(temp_map_file):
+                    map_file = temp_map_file
+                elif os.path.isfile(temp_layermap_file):
+                    map_file = temp_layermap_file
+                else:
+                    self.logger.error("Unable to define map file.")
+
+            if tech_file is None:
+                if control_file is None:
+                    temp_control_file = os.path.splitext(inputGDS)[0] + ".xml"
+                    if os.path.isfile(temp_control_file):
+                        control_file = temp_control_file
+                    else:
+                        self.logger.error("Unable to define control file.")
+
+                command = [anstranslator_full_path, inputGDS, f'-g="{map_file}"', f'-c="{control_file}"']
+            else:
+                command = [
+                    anstranslator_full_path,
+                    inputGDS,
+                    f'-o="{control_file_temp}"' f'-t="{tech_file}"',
+                    f'-g="{map_file}"',
+                    f'-f="{layer_filter}"',
+                ]
+
+            result = subprocess.run(command, capture_output=True, text=True, shell=True)
+            print(result.stdout)
+            print(command)
+            temp_inputGDS = inputGDS.split(".gds")[0]
+            self.edbpath = temp_inputGDS + ".aedb"
+            return self.open_edb()
 
     def _create_extent(
         self,
@@ -1630,6 +1666,14 @@ class Edb(Database):
                     )
                 else:
                     obj_data = i.Expand(expansion_size, tolerance, round_corner, round_extension)
+                if inlcude_voids_in_extents and "PolygonData" not in str(i) and i.has_voids and obj_data:
+                    for void in i.voids:
+                        void_data = void.primitive_object.GetPolygonData().Expand(
+                            -1 * expansion_size, tolerance, round_corner, round_extension
+                        )
+                        if void_data:
+                            for v in list(void_data):
+                                obj_data[0].AddHole(v)
                 if obj_data:
                     if not inlcude_voids_in_extents:
                         unite_polys.extend(list(obj_data))
@@ -2200,7 +2244,7 @@ class Edb(Database):
         pins_to_preserve = []
         nets_to_preserve = []
         if preserve_components_with_model:
-            for el in self.components.instances.values():
+            for el in self.layout.groups:
                 if el.model_type in [
                     "SPICEModel",
                     "SParameterModel",
@@ -2209,9 +2253,9 @@ class Edb(Database):
                     pins_to_preserve.extend([i.id for i in el.pins.values()])
                     nets_to_preserve.extend(el.nets)
         if include_pingroups:
-            for reference in reference_list:
-                for pin in self.nets.nets[reference].padstack_instances:
-                    if pin.pingroups:
+            for pingroup in self.padstacks.pingroups:
+                for pin in pingroup.pins.values():
+                    if pin.net_name in reference_list:
                         pins_to_preserve.append(pin.id)
         if check_terminals:
             terms = [
@@ -2229,23 +2273,41 @@ class Edb(Database):
         reference_pinsts = []
         reference_prims = []
         reference_paths = []
-        for i in self.padstacks.instances.values():
-            net_name = i.net_name
-            id = i.id
+        pins_to_delete = []
+
+        def check_instances(item):
+            net_name = item.net_name
+            id = item.id
             if net_name not in all_list and id not in pins_to_preserve:
-                i.delete()
+                pins_to_delete.append(item)
             elif net_name in reference_list and id not in pins_to_preserve:
-                reference_pinsts.append(i)
-        for i in self.modeler.primitives:
-            if i:
-                net_name = i.net_name
+                reference_pinsts.append(item)
+
+        with ThreadPoolExecutor(number_of_threads) as pool:
+            pool.map(lambda item: check_instances(item), self.layout.padstack_instances)
+
+        for i in pins_to_delete:
+            i.delete()
+
+        prim_to_delete = []
+
+        def check_prims(item):
+            if item:
+                net_name = item.net_name
                 if net_name not in all_list:
-                    i.delete()
-                elif net_name in reference_list and not i.is_void:
-                    if keep_lines_as_path and i.type == "Path":
-                        reference_paths.append(i)
+                    prim_to_delete.append(item)
+                elif net_name in reference_list and not item.is_void:
+                    if keep_lines_as_path and item.type == "Path":
+                        reference_paths.append(item)
                     else:
-                        reference_prims.append(i)
+                        reference_prims.append(item)
+
+        with ThreadPoolExecutor(number_of_threads) as pool:
+            pool.map(lambda item: check_prims(item), self.modeler.primitives)
+
+        for i in prim_to_delete:
+            i.delete()
+
         self.logger.info_timer("Net clean up")
         self.logger.reset_timer()
 
@@ -2280,17 +2342,17 @@ class Edb(Database):
             if extent_type in ["Conforming", self.edb_api.geometry.extent_type.Conforming, 1]:
                 if extent_defeature > 0:
                     _poly = _poly.Defeature(extent_defeature)
-
                 _poly1 = _poly.CreateFromArcs(_poly.GetArcData(), True)
                 if inlcude_voids_in_extents:
                     for hole in list(_poly.Holes):
                         if hole.Area() >= 0.05 * _poly1.Area():
                             _poly1.AddHole(hole)
+                    self.logger.info(f"Number of voids included:{len(list(_poly1.Holes))}")
                 _poly = _poly1
         if not _poly or _poly.IsNull():
             self._logger.error("Failed to create Extent.")
             return []
-        self.logger.info_timer("Expanded Net Polygon Creation")
+        self.logger.info_timer("Extent Creation")
         self.logger.reset_timer()
         _poly_list = convert_py_list_to_net_list([_poly])
         prims_to_delete = []
@@ -2373,20 +2435,17 @@ class Edb(Database):
         for pin in pins_to_delete:
             pin.delete()
 
-        self.logger.info_timer(
-            "Padstack Instances removal completed. {} instances removed.".format(len(pins_to_delete))
-        )
+        self.logger.info_timer("{} Padstack Instances deleted.".format(len(pins_to_delete)))
         self.logger.reset_timer()
 
-        # with ThreadPoolExecutor(number_of_threads) as pool:
-        #     pool.map(lambda item: clip_path(item), reference_paths)
-
-        for item in reference_paths:
-            clip_path(item)
-        for prim in reference_prims:  # removing multithreading as failing with new layer from primitive
-            clean_prim(prim)
-        # with ThreadPoolExecutor(number_of_threads) as pool:
-        #    pool.map(lambda item: clean_prim(item), reference_prims)
+        with ThreadPoolExecutor(number_of_threads) as pool:
+            pool.map(lambda item: clip_path(item), reference_paths)
+        with ThreadPoolExecutor(number_of_threads) as pool:
+            pool.map(lambda item: clean_prim(item), reference_prims)
+        # for item in reference_paths:
+        #     clip_path(item)
+        # for prim in reference_prims:  # removing multithreading as failing with new layer from primitive
+        #     clean_prim(prim)
 
         for el in poly_to_create:
             self.modeler.create_polygon(el[0], el[1], net_name=el[2], voids=el[3])
@@ -2394,7 +2453,7 @@ class Edb(Database):
         for prim in prims_to_delete:
             prim.delete()
 
-        self.logger.info_timer("Primitives cleanup completed. {} primitives deleted.".format(len(prims_to_delete)))
+        self.logger.info_timer("{} Primitives deleted.".format(len(prims_to_delete)))
         self.logger.reset_timer()
 
         i = 0
@@ -2403,7 +2462,7 @@ class Edb(Database):
                 val.edbcomponent.Delete()
                 i += 1
                 i += 1
-        self.logger.info("Deleted {} additional components".format(i))
+        self.logger.info("{} components deleted".format(i))
         if remove_single_pin_components:
             self.components.delete_single_pin_rlc()
             self.logger.info_timer("Single Pins components deleted")