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

pyedb/dotnet/database/modeler.py

@@ -307,9 +307,13 @@ class Modeler(object):
         _obj_instances = list(self._pedb.layout_instance.FindLayoutObjInstance(pt, None, nets).Items)
         returned_obj = []
         if layer:
-            selected_obj = [obj for obj in _obj_instances if layer in [lay.GetName() for lay in list(obj.GetLayers())]]
-            for obj in selected_obj:
-                prim = obj.GetLayoutObj()
+            selected_prim = [
+                obj.GetLayoutObj()
+                for obj in _obj_instances
+                if layer in [lay.GetName() for lay in list(obj.GetLayers())]
+                and "Terminal" not in str(obj.GetLayoutObj())
+            ]
+            for prim in selected_prim:
                 obj_id = prim.GetId()
                 prim_type = str(prim.GetPrimitiveType())
                 if prim_type == "Polygon":
@@ -321,7 +325,10 @@ class Modeler(object):
         else:
             for obj in _obj_instances:
                 obj_id = obj.GetLayoutObj().GetId()
-                [returned_obj.append(p) for p in [obj for obj in self.primitives if obj.id == obj_id]]
+                [
+                    returned_obj.append(Primitive(p, self._pedb))
+                    for p in [obj for obj in self.primitives if obj.id == obj_id]
+                ]
         return returned_obj
 
     def get_polygon_bounding_box(self, polygon):

pyedb/dotnet/edb.py

@@ -46,6 +46,7 @@ from pyedb.dotnet.database.Variables import decompose_variable_value
 from pyedb.dotnet.database.cell.layout import Layout
 from pyedb.dotnet.database.cell.terminal.terminal import Terminal
 from pyedb.dotnet.database.components import Components
+import pyedb.dotnet.database.dotnet.database
 from pyedb.dotnet.database.dotnet.database import Database
 from pyedb.dotnet.database.edb_data.control_file import (
     ControlFile,
@@ -761,6 +762,23 @@ class Edb(Database):
         """Active cell."""
         return self._active_cell
 
+    @active_cell.setter
+    def active_cell(self, value):
+        if isinstance(value, str):
+            _cell = [cell for cell in self.circuit_cells if cell.GetName() == value]
+            if _cell:
+                self._active_cell = _cell[0]
+                self._init_objects()
+                self.logger.info(f"Cell {value} set as active")
+            else:
+                raise f"Design {value} not found in database."
+        elif isinstance(value, pyedb.dotnet.database.dotnet.database.CellClassDotNet):
+            self._active_cell = value
+            self._init_objects()
+            self.logger.info(f"Cell {value.GetName()} set as active")
+        else:
+            raise "No valid design."
+
     @property
     def core_components(self):  # pragma: no cover
         """Edb Components methods and properties.

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