pyedb 0.39.1__py3-none-any.whl → 0.40.0__py3-none-any.whl

pyedb/grpc/database/components.py

@@ -54,6 +54,7 @@ from pyedb.grpc.database.definition.component_pin import ComponentPin
 from pyedb.grpc.database.hierarchy.component import Component
 from pyedb.grpc.database.hierarchy.pin_pair_model import PinPairModel
 from pyedb.grpc.database.hierarchy.pingroup import PinGroup
+from pyedb.grpc.database.padstacks import Padstacks
 from pyedb.grpc.database.utility.sources import SourceType
 from pyedb.modeler.geometry_operators import GeometryOperators
 
@@ -119,17 +120,10 @@ class Components(object):
 
     def __init__(self, p_edb):
         self._pedb = p_edb
-        self._cmp = {}
-        self._res = {}
-        self._cap = {}
-        self._ind = {}
-        self._ios = {}
-        self._ics = {}
-        self._others = {}
+        self.refresh_components()
         self._pins = {}
         self._comps_by_part = {}
-        self._init_parts()
-        # self._padstack = Padstacks(self._pedb)
+        self._padstack = Padstacks(self._pedb)
         # self._excitations = self._pedb.excitations
 
     @property
@@ -137,16 +131,6 @@ class Components(object):
         """Logger."""
         return self._pedb.logger
 
-    def _init_parts(self):
-        a = self.instances
-        a = self.resistors
-        a = self.ICs
-        a = self.Others
-        a = self.inductors
-        a = self.IOs
-        a = self.components_by_partname
-        return True
-
     @property
     def _active_layout(self):
         return self._pedb.active_layout
@@ -180,8 +164,6 @@ class Components(object):
         >>> edbapp.components.instances
 
         """
-        if not self._cmp:
-            self.refresh_components()
         return self._cmp
 
     @property
@@ -287,10 +269,28 @@ class Components(object):
         """Refresh the component dictionary."""
         self._logger.info("Refreshing the Components dictionary.")
         self._cmp = {}
+        self._res = {}
+        self._ind = {}
+        self._cap = {}
+        self._ics = {}
+        self._ios = {}
+        self._others = {}
         for i in self._pedb.layout.groups:
-            if isinstance(i, Component):
-                if not i.is_null:
-                    self._cmp[i.name] = i
+            self._cmp[i.name] = i
+            if i.type == "resistor":
+                self._res[i.name] = i
+            elif i.type == "capacitor":
+                self._cap[i.name] = i
+            elif i.type == "inductor":
+                self._ind[i.name] = i
+            elif i.type == "ic":
+                self._ics[i.name] = i
+            elif i.type == "io":
+                self._ios[i.name] = i
+            elif i.type == "other":
+                self._others[i.name] = i
+            else:
+                self._logger.warning(f"Unknown component type {i.name} found while refreshing components, will ignore")
         return True
 
     @property
@@ -309,14 +309,6 @@ class Components(object):
         >>> edbapp = Edb("myaedbfolder")
         >>> edbapp.components.resistors
         """
-        self._res = {}
-        for el, val in self.instances.items():
-            if not val.is_null:
-                try:
-                    if val.type == "resistor":
-                        self._res[el] = val
-                except:
-                    pass
         return self._res
 
     @property
@@ -335,14 +327,6 @@ class Components(object):
         >>> edbapp = Edb("myaedbfolder")
         >>> edbapp.components.capacitors
         """
-        self._cap = {}
-        for el, val in self.instances.items():
-            if not val.is_null:
-                try:
-                    if val.type == "capacitor":
-                        self._cap[el] = val
-                except:
-                    pass
         return self._cap
 
     @property
@@ -362,14 +346,6 @@ class Components(object):
         >>> edbapp.components.inductors
 
         """
-        self._ind = {}
-        for el, val in self.instances.items():
-            if not val.is_null:
-                try:
-                    if val.type == "inductor":
-                        self._ind[el] = val
-                except:
-                    pass
         return self._ind
 
     @property
@@ -389,14 +365,6 @@ class Components(object):
         >>> edbapp.components.ICs
 
         """
-        self._ics = {}
-        for el, val in self.instances.items():
-            if not val.is_null:
-                try:
-                    if val.type == "ic":
-                        self._ics[el] = val
-                except:
-                    pass
         return self._ics
 
     @property
@@ -416,14 +384,6 @@ class Components(object):
         >>> edbapp.components.IOs
 
         """
-        self._ios = {}
-        for el, val in self.instances.items():
-            if not val.is_null:
-                try:
-                    if val.type == "io":
-                        self._ios[el] = val
-                except:
-                    pass
         return self._ios
 
     @property
@@ -443,14 +403,6 @@ class Components(object):
         >>> edbapp.components.others
 
         """
-        self._others = {}
-        for el, val in self.instances.items():
-            if not val.is_null:
-                try:
-                    if val.type == "other":
-                        self._others[el] = val
-                except:
-                    pass
         return self._others
 
     @property

pyedb/grpc/database/definition/materials.py

@@ -26,7 +26,7 @@ import difflib
 import logging
 import os
 import re
-from typing import Optional
+from typing import Optional, Union
 import warnings
 
 from ansys.edb.core.definition.debye_model import DebyeModel as GrpcDebyeModel
@@ -1205,3 +1205,18 @@ class Materials(object):
 
         self.__edb.logger.error(f"Material {material_name} does not exist in syslib AMAT file.")
         return res
+
+    def update_materials_from_sys_library(self, update_all: bool = True, material_name: Union[str, list] = None):
+        """Update material properties from syslib AMAT file."""
+        amat_file = os.path.join(self.__edb.base_path, "syslib", "Materials.amat")
+        materials_dict = self.read_materials(amat_file)
+        if update_all:
+            for name, obj in self.materials.items():
+                if name in materials_dict:
+                    obj.update(materials_dict[name])
+                    self.__edb.logger.info(f"Material {name} is updated from syslibrary.")
+        else:
+            material_names = material_name if isinstance(material_name, list) else [material_name]
+            for name in material_names:
+                self.materials[name].update(materials_dict[name])
+                self.__edb.logger.info(f"Material {name} is updated from syslibrary.")

pyedb/grpc/database/layout/layout.py

@@ -26,6 +26,7 @@ This module contains these classes: `EdbLayout` and `Shape`.
 from typing import Union
 
 from ansys.edb.core.layout.layout import Layout as GrpcLayout
+import ansys.edb.core.primitive.primitive
 
 from pyedb.grpc.database.hierarchy.component import Component
 from pyedb.grpc.database.hierarchy.pingroup import PinGroup
@@ -34,7 +35,12 @@ from pyedb.grpc.database.net.differential_pair import DifferentialPair
 from pyedb.grpc.database.net.extended_net import ExtendedNet
 from pyedb.grpc.database.net.net import Net
 from pyedb.grpc.database.net.net_class import NetClass
+from pyedb.grpc.database.primitive.bondwire import Bondwire
+from pyedb.grpc.database.primitive.circle import Circle
 from pyedb.grpc.database.primitive.padstack_instance import PadstackInstance
+from pyedb.grpc.database.primitive.path import Path
+from pyedb.grpc.database.primitive.polygon import Polygon
+from pyedb.grpc.database.primitive.rectangle import Rectangle
 from pyedb.grpc.database.terminal.bundle_terminal import BundleTerminal
 from pyedb.grpc.database.terminal.edge_terminal import EdgeTerminal
 from pyedb.grpc.database.terminal.padstack_instance_terminal import (
@@ -59,6 +65,24 @@ class Layout(GrpcLayout):
         """
         return self._pedb._active_cell
 
+    @property
+    def primitives(self):
+        prims = []
+        for prim in super().primitives:
+            if isinstance(prim, ansys.edb.core.primitive.primitive.Path):
+                prims.append(Path(self._pedb, prim))
+            elif isinstance(prim, ansys.edb.core.primitive.primitive.Polygon):
+                prims.append(Polygon(self._pedb, prim))
+            elif isinstance(prim, ansys.edb.core.primitive.primitive.PadstackInstance):
+                prims.append(PadstackInstance(self._pedb, prim))
+            elif isinstance(prim, ansys.edb.core.primitive.primitive.Rectangle):
+                prims.append(Rectangle(self._pedb, prim))
+            elif isinstance(prim, ansys.edb.core.primitive.primitive.Circle):
+                prims.append(Circle(self._pedb, prim))
+            elif isinstance(prim, ansys.edb.core.primitive.primitive.Bondwire):
+                prims.append(Bondwire(self._pedb, prim))
+        return prims
+
     @property
     def terminals(self):
         """Get terminals belonging to active layout.
@@ -180,17 +204,32 @@ class Layout(GrpcLayout):
         """
         return [VoltageRegulator(self._pedb, i) for i in self._pedb.active_cell.layout.voltage_regulators]
 
-    def find_primitive(self, layer_name: Union[str, list]) -> list:
+    def find_primitive(
+        self, layer_name: Union[str, list] = None, name: Union[str, list] = None, net_name: Union[str, list] = None
+    ) -> list:
         """Find a primitive objects by layer name.
-
         Parameters
         ----------
         layer_name : str, list
+        layer_name : str, list, optional
             Name of the layer.
+        name : str, list, optional
+            Name of the primitive
+        net_name : str, list, optional
+            Name of the primitive
         Returns
         -------
         List[:class:`Primitive <pyedb.grpc.database.primitive.primitive.Primitive`].
             List of Primitive.
         """
-        layer_name = layer_name if isinstance(layer_name, list) else [layer_name]
-        return [i for i in self.primitives if i.layer.name in layer_name]
+        if layer_name:
+            layer_name = layer_name if isinstance(layer_name, list) else [layer_name]
+        if name:
+            name = name if isinstance(name, list) else [name]
+        if net_name:
+            net_name = net_name if isinstance(net_name, list) else [net_name]
+        prims = self.primitives
+        prims = [i for i in prims if i.aedt_name in name] if name is not None else prims
+        prims = [i for i in prims if i.layer_name in layer_name] if layer_name is not None else prims
+        prims = [i for i in prims if i.net_name in net_name] if net_name is not None else prims
+        return prims

pyedb/grpc/database/layout_validation.py

@@ -22,8 +22,11 @@
 
 import re
 
-# from pyedb.generic.general_methods import generate_unique_name
-# from pyedb.grpc.database.primitive.padstack_instances import PadstackInstance
+from ansys.edb.core.database import ProductIdType as GrpcProductIdType
+
+from pyedb.generic.general_methods import generate_unique_name
+from pyedb.grpc.database.primitive.padstack_instance import PadstackInstance
+
 # from pyedb.grpc.database.primitive.primitive import Primitive
 
 
@@ -120,146 +123,145 @@ class LayoutValidation:
                         i.net = self._pedb.nets.nets[temp_name]
         return dc_shorts
 
-    # def disjoint_nets(
-    #         self,
-    #         net_list=None,
-    #         keep_only_main_net=False,
-    #         clean_disjoints_less_than=0.0,
-    #         order_by_area=False,
-    #         keep_disjoint_pins=False,
-    # ):
-    #     """Find and fix disjoint nets from a given netlist.
-    #
-    #     Parameters
-    #     ----------
-    #     net_list : str, list, optional
-    #         List of nets on which check disjoints. If `None` is provided then the algorithm will loop on all nets.
-    #     keep_only_main_net : bool, optional
-    #         Remove all secondary nets other than principal one (the one with more objects in it). Default is `False`.
-    #     clean_disjoints_less_than : bool, optional
-    #       Clean all disjoint nets with area less than specified area in square meters. Default is `0.0` to disable it.
-    #     order_by_area : bool, optional
-    #         Whether if the naming order has to be by number of objects (fastest) or area (slowest but more accurate).
-    #         Default is ``False``.
-    #     keep_disjoint_pins : bool, optional
-    #         Whether if delete disjoints pins not connected to any other primitive or not. Default is ``False``.
-    #
-    #     Returns
-    #     -------
-    #     List
-    #         New nets created.
-    #
-    #     Examples
-    #     --------
-    #
-    #     >>> renamed_nets = edb.layout_validation.disjoint_nets(["GND","Net2"])
-    #     """
-    #     from ansys.edb.core.geometry.point_data import PointData as GrpcPointData
-    #     timer_start = self._pedb.logger.reset_timer()
-    #
-    #     if not net_list:
-    #         net_list = list(self._pedb.nets.keys())
-    #     elif isinstance(net_list, str):
-    #         net_list = [net_list]
-    #     _objects_list = {}
-    #     _padstacks_list = {}
-    #     for prim in self._pedb.modeler.primitives:
-    #         if not prim.net.is_null:
-    #             n_name = prim.net.name
-    #             if n_name in _objects_list:
-    #                 _objects_list[n_name].append(prim)
-    #             else:
-    #                 _objects_list[n_name] = [prim]
-    #     for pad in list(self._pedb.padstacks.instances.values()):
-    #         if not pad.net.is_null:
-    #             n_name = pad.net_name
-    #             if n_name in _padstacks_list:
-    #                 _padstacks_list[n_name].append(pad)
-    #             else:
-    #                 _padstacks_list[n_name] = [pad]
-    #     new_nets = []
-    #     disjoints_objects = []
-    #     self._pedb.logger.reset_timer()
-    #     for net in net_list:
-    #         net_groups = []
-    #         obj_dict = {}
-    #         for i in _objects_list.get(net, []):
-    #             obj_dict[i.id] = i
-    #         for i in _padstacks_list.get(net, []):
-    #             obj_dict[i.id] = i
-    #         objs = list(obj_dict.values())
-    #         l = len(objs)
-    #         while l > 0:
-    #             l1 = self._layout_instance.get_connected_objects(objs[0].layout_object_instance, False)
-    #             l1.append(objs[0].id)
-    #             repetition = False
-    #             for net_list in net_groups:
-    #                 if set(l1).intersection(net_list):
-    #                     net_groups.append([i for i in l1 if i not in net_list])
-    #                     repetition = True
-    #             if not repetition:
-    #                 net_groups.append(l1)
-    #             objs = [i for i in objs if i.id not in l1]
-    #             l = len(objs)
-    #         if len(net_groups) > 1:
-    #
-    #             def area_calc(elem):
-    #                 sum = 0
-    #                 for el in elem:
-    #                     try:
-    #                         if el.layout_obj.obj_type.value == 0:
-    #                             if not el.is_void:
-    #                                 sum += el.area()
-    #                     except:
-    #                         pass
-    #                 return sum
-    #
-    #             if order_by_area:
-    #                 areas = [area_calc(i) for i in net_groups]
-    #                 sorted_list = [x for _, x in sorted(zip(areas, net_groups), reverse=True)]
-    #             else:
-    #                 sorted_list = sorted(net_groups, key=len, reverse=True)
-    #             for disjoints in sorted_list[1:]:
-    #                 if keep_only_main_net:
-    #                     for geo in disjoints:
-    #                         try:
-    #                             obj_dict[geo].delete()
-    #                         except KeyError:
-    #                             pass
-    #                 elif len(disjoints) == 1 and (
-    #                         clean_disjoints_less_than
-    #                         and "area" in dir(obj_dict[disjoints[0]])
-    #                         and obj_dict[disjoints[0]].area() < clean_disjoints_less_than
-    #                 ):
-    #                     try:
-    #                         obj_dict[disjoints[0]].delete()
-    #                     except KeyError:
-    #                         pass
-    #                 elif (
-    #                         len(disjoints) == 1
-    #                         and not keep_disjoint_pins
-    #                         and isinstance(obj_dict[disjoints[0]], PadstackInstance)
-    #                 ):
-    #                     try:
-    #                         obj_dict[disjoints[0]].delete()
-    #                     except KeyError:
-    #                         pass
-    #
-    #                 else:
-    #                     new_net_name = generate_unique_name(net, n=6)
-    #                     net_obj = self._pedb.nets.find_or_create_net(new_net_name)
-    #                     if net_obj:
-    #                         new_nets.append(net_obj.name)
-    #                         for geo in disjoints:
-    #                             try:
-    #                                 obj_dict[geo].net_name = net_obj.name
-    #                             except KeyError:
-    #                                 pass
-    #                         disjoints_objects.extend(disjoints)
-    #     self._pedb._logger.info("Found {} objects in {} new nets.".format(len(disjoints_objects), len(new_nets)))
-    #     self._pedb._logger.info_timer("Disjoint Cleanup Completed.", timer_start)
-    #
-    #     return new_nets
+    def disjoint_nets(
+        self,
+        net_list=None,
+        keep_only_main_net=False,
+        clean_disjoints_less_than=0.0,
+        order_by_area=False,
+        keep_disjoint_pins=False,
+    ):
+        """Find and fix disjoint nets from a given netlist.
+
+        Parameters
+        ----------
+        net_list : str, list, optional
+            List of nets on which check disjoints. If `None` is provided then the algorithm will loop on all nets.
+        keep_only_main_net : bool, optional
+            Remove all secondary nets other than principal one (the one with more objects in it). Default is `False`.
+        clean_disjoints_less_than : bool, optional
+          Clean all disjoint nets with area less than specified area in square meters. Default is `0.0` to disable it.
+        order_by_area : bool, optional
+            Whether if the naming order has to be by number of objects (fastest) or area (slowest but more accurate).
+            Default is ``False``.
+        keep_disjoint_pins : bool, optional
+            Whether if delete disjoints pins not connected to any other primitive or not. Default is ``False``.
+
+        Returns
+        -------
+        List
+            New nets created.
+
+        Examples
+        --------
+
+        >>> renamed_nets = edb.layout_validation.disjoint_nets(["GND","Net2"])
+        """
+        timer_start = self._pedb.logger.reset_timer()
+
+        if not net_list:
+            net_list = list(self._pedb.nets.keys())
+        elif isinstance(net_list, str):
+            net_list = [net_list]
+        _objects_list = {}
+        _padstacks_list = {}
+        for prim in self._pedb.modeler.primitives:
+            if not prim.net.is_null:
+                n_name = prim.net.name
+                if n_name in _objects_list:
+                    _objects_list[n_name].append(prim)
+                else:
+                    _objects_list[n_name] = [prim]
+        for pad in list(self._pedb.padstacks.instances.values()):
+            if not pad.net.is_null:
+                n_name = pad.net_name
+                if n_name in _padstacks_list:
+                    _padstacks_list[n_name].append(pad)
+                else:
+                    _padstacks_list[n_name] = [pad]
+        new_nets = []
+        disjoints_objects = []
+        self._pedb.logger.reset_timer()
+        for net in net_list:
+            net_groups = []
+            obj_dict = {}
+            for i in _objects_list.get(net, []):
+                obj_dict[i.id] = i
+            for i in _padstacks_list.get(net, []):
+                obj_dict[i.id] = i
+            objs = list(obj_dict.values())
+            l = len(objs)
+            while l > 0:
+                l1 = self._layout_instance.get_connected_objects(objs[0].layout_object_instance, False)
+                l1.append(objs[0].id)
+                repetition = False
+                for net_list in net_groups:
+                    if set(l1).intersection(net_list):
+                        net_groups.append([i for i in l1 if i not in net_list])
+                        repetition = True
+                if not repetition:
+                    net_groups.append(l1)
+                objs = [i for i in objs if i.id not in l1]
+                l = len(objs)
+            if len(net_groups) > 1:
+
+                def area_calc(elem):
+                    sum = 0
+                    for el in elem:
+                        try:
+                            if el.layout_obj.obj_type.value == 0:
+                                if not el.is_void:
+                                    sum += el.area()
+                        except:
+                            pass
+                    return sum
+
+                if order_by_area:
+                    areas = [area_calc(i) for i in net_groups]
+                    sorted_list = [x for _, x in sorted(zip(areas, net_groups), reverse=True)]
+                else:
+                    sorted_list = sorted(net_groups, key=len, reverse=True)
+                for disjoints in sorted_list[1:]:
+                    if keep_only_main_net:
+                        for geo in disjoints:
+                            try:
+                                obj_dict[geo].delete()
+                            except KeyError:
+                                pass
+                    elif len(disjoints) == 1 and (
+                        clean_disjoints_less_than
+                        and "area" in dir(obj_dict[disjoints[0]])
+                        and obj_dict[disjoints[0]].area() < clean_disjoints_less_than
+                    ):
+                        try:
+                            obj_dict[disjoints[0]].delete()
+                        except KeyError:
+                            pass
+                    elif (
+                        len(disjoints) == 1
+                        and not keep_disjoint_pins
+                        and isinstance(obj_dict[disjoints[0]], PadstackInstance)
+                    ):
+                        try:
+                            obj_dict[disjoints[0]].delete()
+                        except KeyError:
+                            pass
+
+                    else:
+                        new_net_name = generate_unique_name(net, n=6)
+                        net_obj = self._pedb.nets.find_or_create_net(new_net_name)
+                        if net_obj:
+                            new_nets.append(net_obj.name)
+                            for geo in disjoints:
+                                try:
+                                    obj_dict[geo].net_name = net_obj.name
+                                except KeyError:
+                                    pass
+                            disjoints_objects.extend(disjoints)
+        self._pedb._logger.info("Found {} objects in {} new nets.".format(len(disjoints_objects), len(new_nets)))
+        self._pedb._logger.info_timer("Disjoint Cleanup Completed.", timer_start)
+
+        return new_nets
 
     def fix_self_intersections(self, net_list=None):
         """Find and fix self intersections from a given netlist.
@@ -274,7 +276,7 @@ class LayoutValidation:
         bool
         """
         if not net_list:
-            net_list = list(self._pedb.nets.keys())
+            net_list = list(self._pedb.nets.nets.keys())
         elif isinstance(net_list, str):
             net_list = [net_list]
         new_prims = []
@@ -317,3 +319,22 @@ class LayoutValidation:
                     v.rlc_values = [0, 1, 0]
         self._pedb._logger.info(f"Found {len(temp)} inductors have no value.")
         return
+
+    def padstacks_no_name(self, fix=False):
+        pds = self._pedb.layout.padstack_instances
+        counts = 0
+        via_count = 1
+        for obj in pds:
+            name = obj.get_product_property(GrpcProductIdType.DESIGNER, 11)
+            name = str(name).strip("'")
+            if name == "":
+                counts += 1
+                if fix:
+                    if not obj.component:
+                        obj.set_product_property(GrpcProductIdType.DESIGNER, 11, f"Via{via_count}")
+                        via_count = via_count + 1
+                    else:
+                        obj.set_product_property(
+                            GrpcProductIdType.DESIGNER, 11, f"{obj.component.name}-{obj.component_pin}"
+                        )
+        self._pedb._logger.info(f"Found {counts}/{len(pds)} padstacks have no name.")

pyedb/grpc/database/net/net.py

@@ -122,13 +122,7 @@ class Net(GrpcNet):
         return self._pedb.layout_validation.dc_shorts(self.name, fix)
 
     def plot(
-        self,
-        layers=None,
-        show_legend=True,
-        save_plot=None,
-        outline=None,
-        size=(2000, 1000),
-        show=True,
+        self, layers=None, show_legend=True, save_plot=None, outline=None, size=(2000, 1000), show=True, title=None
     ):
         """Plot a net to Matplotlib 2D chart.
 
@@ -147,7 +141,9 @@ class Net(GrpcNet):
         size : tuple, optional
             Image size in pixel (width, height).
         show : bool, optional
-            Whether to show the plot or not. Default is `True`.
+            Whether to show the plot or not. Default is ``True``.
+        title : str, optional
+            Plot title. If value is ``None`` the project name is assigned by default. Default value is ``None``.
         """
 
         self._pedb.nets.plot(
@@ -160,6 +156,7 @@ class Net(GrpcNet):
             show=show,
             plot_components=True,
             plot_vias=True,
+            title=None,
         )
 
     def get_smallest_trace_width(self):