pyedb 0.54.0__py3-none-any.whl → 0.56.0__py3-none-any.whl

pyedb/grpc/database/padstacks.py

@@ -93,8 +93,7 @@ class Padstacks(object):
 
     def __init__(self, p_edb: Any) -> None:
         self._pedb = p_edb
-        self._instances: Dict[int, PadstackInstance] = {}
-        self._definitions: Dict[str, Any] = {}
+        self.__definitions: Dict[str, Any] = {}
 
     @property
     def _active_layout(self) -> Any:
@@ -211,13 +210,12 @@ class Padstacks(object):
         >>> for name, definition in all_definitions.items():
         ...     print(f"Padstack: {name}")
         """
-        if len(self._definitions) == len(self.db.padstack_defs):
-            return self._definitions
-        self._definitions = {}
-        for padstack_def in self._pedb.db.padstack_defs:
+        padstack_defs = self._pedb.db.padstack_defs
+        self.__definitions = {}
+        for padstack_def in padstack_defs:
             if len(padstack_def.data.layer_names) >= 1:
-                self._definitions[padstack_def.name] = PadstackDef(self._pedb, padstack_def)
-        return self._definitions
+                self.__definitions[padstack_def.name] = PadstackDef(self._pedb, padstack_def)
+        return self.__definitions
 
     @property
     def instances(self) -> Dict[int, PadstackInstance]:
@@ -230,15 +228,11 @@ class Padstacks(object):
 
         Examples
         --------
-        >>> all_instances = edb_padstacks.instances
+        >>> all_instances = edb.padstacks.instances
         >>> for id, instance in all_instances.items():
         ...     print(f"Instance {id}: {instance.name}")
         """
-        pad_stack_inst = self._pedb.layout.padstack_instances
-        if len(self._instances) == len(pad_stack_inst):
-            return self._instances
-        self._instances = {i.edb_uid: PadstackInstance(self._pedb, i) for i in pad_stack_inst}
-        return self._instances
+        return self._pedb.layout.padstack_instances
 
     @property
     def instances_by_name(self) -> Dict[str, PadstackInstance]:
@@ -348,6 +342,7 @@ class Padstacks(object):
     @property
     def pad_type(self) -> GrpcPadType:
         """Return a PadType Enumerator."""
+        return GrpcPadType
 
     def create_circular_padstack(
         self,
@@ -800,7 +795,7 @@ class Padstacks(object):
         if net_list and not isinstance(net_list, list):
             net_list = [net_list]
         via_list = []
-        for inst in self._layout.padstack_instances:
+        for inst_id, inst in self._layout.padstack_instances.items():
             pad_layers_name = inst.padstack_def.data.layer_names
             if len(pad_layers_name) > 1:
                 if not net_list:
@@ -1150,7 +1145,7 @@ class Padstacks(object):
             padstack_instance.is_layout_pin = is_pin
             return PadstackInstance(self._pedb, padstack_instance)
         else:
-            return False
+            raise RuntimeError("Place padstack failed")
 
     def remove_pads_from_padstack(self, padstack_name: str, layer_name: Optional[str] = None):
         """Remove pads from a padstack definition on specified layers.
@@ -1287,6 +1282,29 @@ class Padstacks(object):
         self.definitions[padstack_name].data = new_padstack_def
         return True
 
+    def get_padstack_instance_by_net_name(self, net: str):
+        """Get padstack instances by net name.
+
+        .. deprecated:: 0.55.0
+        Use: :func:`get_instances` with `net_name` parameter instead.
+
+        Parameters
+        ----------
+        net : str
+            Net name to filter padstack instances.
+
+        Returns
+        -------
+        list[:class:`pyedb.grpc.database.primitive.padstack_instance.PadstackInstance`]
+            List of padstack instances associated with the specified net.
+        """
+        warnings.warn(
+            "`get_padstack_instance_by_net_name` is deprecated, use `get_instances` with `net_name` "
+            "parameter instead.",
+            DeprecationWarning,
+        )
+        return self.get_instances(net_name=net)
+
     def get_instances(
         self,
         name: Optional[str] = None,
@@ -1322,7 +1340,7 @@ class Padstacks(object):
         if pid:
             return instances_by_id[pid]
         elif name:
-            instances = [inst for inst in list(self.instances.values()) if inst.name == name]
+            instances = [inst for inst in list(self.instances.values()) if inst.aedt_name == name]
             if instances:
                 return instances
         else:
@@ -1835,3 +1853,90 @@ class Padstacks(object):
             clusters[int(label)].append(padstack_ids[i])
 
         return dict(clusters)
+
+    def reduce_via_by_density(
+        self, padstacks: List[int], cell_size_x: float = 1e-3, cell_size_y: float = 1e-3, delete: bool = False
+    ) -> tuple[List[int], List[List[List[float]]]]:
+        """
+        Reduce the number of vias by density. Keep only one via which is closest to the center of the cell. The cells
+        are automatically populated based on the input vias.
+
+        Parameters
+        ----------
+        padstacks: List[int]
+            List of padstack ids to be reduced.
+
+        cell_size_x : float
+            Width of each grid cell (default is 1e-3).
+
+        cell_size_y : float
+            Height of each grid cell (default is 1e-3).
+
+        delete: bool
+            If True, delete vias that are not kept (default is False).
+
+        Returns
+        -------
+        List[int]
+            IDs of vias kept after reduction.
+
+        List[List[float]]
+            coordinates for grid lines (for plotting).
+
+        """
+        to_keep = set()
+
+        all_instances = self.instances
+        positions = np.array([all_instances[_id].position for _id in padstacks])
+
+        x_coords, y_coords = positions[:, 0], positions[:, 1]
+        x_min, x_max = np.min(x_coords), np.max(x_coords)
+        y_min, y_max = np.min(y_coords), np.max(y_coords)
+
+        padstacks_array = np.array(padstacks)
+        cell_map = {}  # {(cell_x, cell_y): [(id1, [x1, y1]), (id2, [x2, y2), ...]}
+        grid = []
+
+        for idx, pos in enumerate(positions):
+            i = int((pos[0] - x_min) // cell_size_x)
+            j = int((pos[1] - y_min) // cell_size_y)
+            cell_key = (i, j)
+            cell_map.setdefault(cell_key, []).append((padstacks_array[idx], pos))
+
+        for (i, j), items in cell_map.items():
+            # cell center
+            cell_x_min = x_min + i * cell_size_x
+            cell_y_min = y_min + j * cell_size_y
+            cell_x_mid = cell_x_min + 0.5 * cell_size_x
+            cell_y_mid = cell_y_min + 0.5 * cell_size_y
+
+            grid.append(
+                [
+                    [
+                        cell_x_min,
+                        cell_x_min + cell_size_x,
+                        cell_x_min + cell_size_x,
+                        cell_x_min,
+                        cell_x_min,
+                    ],
+                    [
+                        cell_y_min,
+                        cell_y_min,
+                        cell_y_min + cell_size_y,
+                        cell_y_min + cell_size_y,
+                        cell_y_min,
+                    ],
+                ]
+            )
+
+            # Find closest via to cell center
+            distances = [np.linalg.norm(pos - [cell_x_mid, cell_y_mid]) for _, pos in items]
+            closest_idx = np.argmin(distances)
+            to_keep.add(items[closest_idx][0])
+
+        if delete:
+            to_delete = set(padstacks) - to_keep
+            for _id in to_delete:
+                all_instances[_id].delete()
+
+        return list(to_keep), grid

pyedb/grpc/database/primitive/padstack_instance.py

@@ -22,11 +22,14 @@
 
 import math
 import re
+import warnings
 
 from ansys.edb.core.database import ProductIdType as GrpcProductIdType
 from ansys.edb.core.geometry.point_data import PointData as GrpcPointData
 from ansys.edb.core.geometry.polygon_data import PolygonData as GrpcPolygonData
 from ansys.edb.core.hierarchy.pin_group import PinGroup as GrpcPinGroup
+from ansys.edb.core.hierarchy.structure3d import MeshClosure as GrpcMeshClosure
+from ansys.edb.core.hierarchy.structure3d import Structure3D as GrpcStructure3D
 from ansys.edb.core.primitive.padstack_instance import (
     PadstackInstance as GrpcPadstackInstance,
 )
@@ -34,7 +37,9 @@ from ansys.edb.core.terminal.pin_group_terminal import (
     PinGroupTerminal as GrpcPinGroupTerminal,
 )
 
+from pyedb.generic.general_methods import generate_unique_name
 from pyedb.grpc.database.definition.padstack_def import PadstackDef
+from pyedb.grpc.database.modeler import Circle
 from pyedb.grpc.database.terminal.padstack_instance_terminal import (
     PadstackInstanceTerminal,
 )
@@ -67,6 +72,16 @@ class PadstackInstance(GrpcPadstackInstance):
         self._pedb = pedb
         self._object_instance = None
 
+    @property
+    def is_pin(self):
+        """Property added for backward compatibility with earlier versions of pyEDB."""
+        return self.is_layout_pin
+
+    @is_pin.setter
+    def is_pin(self, value):
+        """Property added for backward compatibility with earlier versions of pyEDB."""
+        self.is_layout_pin = value
+
     @property
     def definition(self) -> PadstackDef:
         """Padstack definition.
@@ -108,6 +123,77 @@ class PadstackInstance(GrpcPadstackInstance):
             term = PadstackInstanceTerminal(self._pedb, term)
         return term if not term.is_null else None
 
+    def set_backdrill_top(self, drill_depth, drill_diameter, offset=0.0):
+        """Set backdrill from top.
+
+        .deprecated:: 0.55.0
+        Use :method:`set_back_drill_by_depth` instead.
+
+        Parameters
+        ----------
+        drill_depth : str
+            Name of the drill to layer.
+        drill_diameter : float, str
+            Diameter of backdrill size.
+        offset : str, optional.
+            offset with respect to the layer to drill to.
+
+        Returns
+        -------
+        bool
+            True if success, False otherwise.
+        """
+        warnings.warn(
+            "`set_backdrill_top` is deprecated. Use `set_back_drill_by_depth` or " "`set_back_drill_by_layer` instead.",
+            DeprecationWarning,
+        )
+        if isinstance(drill_depth, str):
+            if drill_depth in self._pedb.stackup.layers:
+                return self.set_back_drill_by_layer(
+                    drill_to_layer=self._pedb.stackup.layers[drill_depth],
+                    offset=Value(offset),
+                    diameter=Value(drill_diameter),
+                    from_bottom=False,
+                )
+            else:
+                return self.set_back_drill_by_depth(Value(drill_depth), Value(drill_diameter), from_bottom=False)
+
+    def set_backdrill_bottom(self, drill_depth, drill_diameter, offset=0.0):
+        """Set backdrill from bottom.
+
+        .deprecated: 0.55.0
+        Use: method:`set_back_drill_by_depth` instead.
+
+        Parameters
+        ----------
+        drill_depth : str
+            Name of the drill to layer.
+        drill_diameter : float, str
+            Diameter of backdrill size.
+        offset : str, optional.
+            offset with respect to the layer to drill to.
+
+        Returns
+        -------
+        bool
+            True if success, False otherwise.
+        """
+        warnings.warn(
+            "`set_backdrill_bottom` is deprecated. Use `set_back_drill_by_depth` or "
+            "`set_back_drill_by_layer` instead.",
+            DeprecationWarning,
+        )
+        if isinstance(drill_depth, str):
+            if drill_depth in self._pedb.stackup.layers:
+                return self.set_back_drill_by_layer(
+                    drill_to_layer=self._pedb.stackup.layers[drill_depth],
+                    offset=Value(offset),
+                    diameter=Value(drill_diameter),
+                    from_bottom=True,
+                )
+            else:
+                return self.set_back_drill_by_depth(Value(drill_depth), Value(drill_diameter), from_bottom=True)
+
     def create_terminal(self, name=None) -> PadstackInstanceTerminal:
         """Create a padstack instance terminal.
 
@@ -500,13 +586,16 @@ class PadstackInstance(GrpcPadstackInstance):
         list
             List of ``[x, y]`` coordinates for the padstack instance position.
         """
-        position = self.get_position_and_rotation()
-        if self.component:
-            out2 = self.component.transform.transform_point(GrpcPointData(position[:2]))
-            self._position = [Value(out2[0]), Value(out2[1])]
-        else:
-            self._position = [Value(pt) for pt in position[:2]]
-        return self._position
+        try:
+            position = self.get_position_and_rotation()
+            if self.component:
+                out2 = self.component.transform.transform_point(GrpcPointData(position[:2]))
+                self._position = [Value(out2[0]), Value(out2[1])]
+            else:
+                self._position = [Value(pt) for pt in position[:2]]
+            return self._position
+        except Exception:
+            return False
 
     @position.setter
     def position(self, value):
@@ -684,6 +773,85 @@ class PadstackInstance(GrpcPadstackInstance):
     def side_number(self, value):
         self._side_number = self.set_product_property(GrpcProductIdType.HFSS_3D_LAYOUT, 21, value)
 
+    def split(self) -> list:
+        """Split padstack instance into multiple instances. The new instances only connect adjacent layers."""
+        pdef_name = self.padstack_definition
+        position = self.position
+        net_name = self.net_name
+        name = self.name
+        stackup_layer_range = list(self._pedb.stackup.signal_layers.keys())
+        start_idx = stackup_layer_range.index(self.start_layer)
+        stop_idx = stackup_layer_range.index(self.stop_layer)
+        temp = []
+        for idx, (l1, l2) in enumerate(
+            list(zip(stackup_layer_range[start_idx:stop_idx], stackup_layer_range[start_idx + 1 : stop_idx + 1]))
+        ):
+            pd_inst = self._pedb.padstacks.place(
+                position, pdef_name, net_name, f"{name}_{idx}", fromlayer=l1, tolayer=l2
+            )
+            temp.append(pd_inst)
+        self.delete()
+        return temp
+
+    def convert_hole_to_conical_shape(self, angle=75):
+        """Convert actual padstack instance to microvias 3D Objects with a given aspect ratio.
+
+        Parameters
+        ----------
+        angle : float, optional
+            Angle of laser penetration in degrees. The angle defines the lowest hole diameter with this formula:
+            HoleDiameter -2*tan(laser_angle* Hole depth). Hole depth is the height of the via (dielectric thickness).
+            The default is ``75``.
+            The lowest hole is ``0.75*HoleDepth/HoleDiam``.
+
+        Returns
+        -------
+        """
+        stackup_layers = self._pedb.stackup.stackup_layers
+        signal_layers = self._pedb.stackup.signal_layers
+        layer_idx = list(signal_layers.keys()).index(self.start_layer)
+
+        _layer_idx = list(stackup_layers.keys()).index(self.start_layer)
+        diel_layer_idx = list(stackup_layers.keys())[_layer_idx + 1]
+        diel_thickness = stackup_layers[diel_layer_idx].thickness
+
+        rad_large = self.definition.hole_diameter / 2
+        rad_small = rad_large - diel_thickness * 1 / math.tan(math.radians(angle))
+
+        if layer_idx + 1 < len(signal_layers) / 2:  # upper half of stack
+            rad_u = rad_large
+            rad_l = rad_small
+        else:
+            rad_u = rad_small
+            rad_l = rad_large
+
+        layout = self._pedb.active_layout
+        cloned_circle = Circle.create(
+            layout,
+            self.start_layer,
+            self.net,
+            Value(self.position[0]),
+            Value(self.position[1]),
+            Value(rad_u),
+        )
+        cloned_circle2 = Circle.create(
+            layout,
+            self.stop_layer,
+            self.net,
+            Value(self.position[0]),
+            Value(self.position[1]),
+            Value(rad_l),
+        )
+
+        s3d = GrpcStructure3D.create(layout, generate_unique_name("via3d_" + self.aedt_name.replace("via_", ""), n=3))
+        s3d.add_member(cloned_circle)
+        s3d.add_member(cloned_circle2)
+        s3d.set_material(self.definition.material)
+        s3d.mesh_closure = GrpcMeshClosure.ENDS_CLOSED
+        hole_override_enabled = True
+        hole_override_diam = 0
+        self.set_hole_overrides(hole_override_enabled, Value(hole_override_diam))
+
     def get_backdrill_type(self, from_bottom=True):
         """Return backdrill type
         Parameters

pyedb/grpc/database/primitive/polygon.py

@@ -271,6 +271,6 @@ class Polygon(GrpcPolygon, Primitive):
             return False
 
     def add_void(self, polygon):
-        if isinstance(polygon, list):
+        if isinstance(polygon, list) or isinstance(polygon, GrpcPolygonData):
             polygon = self._pedb.modeler.create_polygon(points=polygon, layer_name=self.layer.name)
-        return self._edb_object.add_void(polygon._edb_object)
+        return self._edb_object.add_void(polygon)

pyedb/grpc/database/simulation_setup/siwave_cpa_simulation_setup.py

@@ -1,7 +1,6 @@
 from ansys.edb.core.database import ProductIdType as GrpcProductIdType
 from ansys.edb.core.utility.value import Value as GrpcValue
 
-import pyedb.siwave_core.cpa.simulation_setup_data_model
 from pyedb.siwave_core.cpa.simulation_setup_data_model import SIwaveCpaSetup, Vrm
 from pyedb.siwave_core.product_properties import SIwaveProperties
 
@@ -190,11 +189,13 @@ class ChannelSetup:
         Raises:
             ValueError: If the input is not a list.
         """
+        from pyedb.siwave_core.cpa.simulation_setup_data_model import Vrm
+
         if not isinstance(value, list):
             raise ValueError("vrm setter must have list as input.")
         vrm_str = ""
         for vrm in value:
-            if isinstance(vrm, pyedb.siwave_core.cpa.simulation_setup_data_model.Vrm):
+            if isinstance(vrm, Vrm):
                 if vrm_str:
                     vrm_str += "*"
                 vrm_str += vrm.name

pyedb/grpc/database/siwave.py

@@ -589,7 +589,7 @@ class Siwave(object):
                     f.write('ExportTouchstone "{}"\n'.format(touchstone_file_path))
             f.write("SaveSiw\n")
 
-        return True if os.path.exists(file_name) else False
+        return file_name
 
     def add_cpa_analysis(self, name=None, siwave_cpa_setup_class=None):
         if not name:

pyedb/grpc/database/source_excitations.py

@@ -431,12 +431,10 @@ class SourceExcitation:
             refdes = Component(self._pedb, refdes)
         pins = self._get_pins_for_ports(pins, refdes)
         if not pins:
-            self._logger.error("No pins found during port creation. Port is not defined.")
-            return False
+            raise RuntimeWarning("No pins found during port creation. Port is not defined.")
         reference_pins = self._get_pins_for_ports(reference_pins, refdes)
         if not reference_pins:
-            self._logger.error("No reference pins found during port creation. Port is not defined.")
-            return False
+            raise RuntimeWarning("No reference pins found during port creation. Port is not defined.")
         if refdes and any(refdes.rlc_values):
             return self._pedb.components.deactivate_rlc_component(component=refdes, create_circuit_port=True)
         if not port_name:
@@ -2801,11 +2799,15 @@ class SourceExcitation:
         self,
         terminal: Union[PadstackInstanceTerminal, EdgeTerminal],
         ref_terminal: Union[PadstackInstanceTerminal, EdgeTerminal],
+        magnitude: Union[int, float] = 1,
+        phase: Union[int, float] = 0,
     ) -> bool:
         """Create a voltage source.
 
         Parameters
         ----------
+        name : str, optional
+            Voltage source name
         terminal : :class:`EdgeTerminal <pyedb.grpc.database.terminals.EdgeTerminal>`,
             :class:`PadstackInstanceTerminal <pyedb.grpc.database.terminals.PadstackInstanceTerminal>`,
             :class:`PointTerminal <pyedb.grpc.database.terminals.PointTerminal>`,
@@ -2816,6 +2818,10 @@ class SourceExcitation:
             :class:`PadstackInstanceTerminal <pyedb.grpc.database.terminals.PointTerminal>`,
             :class:`PinGroupTerminal <pyedb.grpc.database.terminals.PinGroupTerminal>`,
             Negative terminal of the source.
+        magnitude : int, float, optional
+            Magnitude of the source.
+        phase : int, float, optional
+            Phase of the source
 
         Returns
         -------
@@ -2834,7 +2840,8 @@ class SourceExcitation:
 
         ref_term = Terminal(self._pedb, ref_terminal)
         ref_term.boundary_type = "voltage_source"
-
+        term.magnitude = self._pedb.value(magnitude)
+        term.phase = self._pedb.value(phase)
         term.ref_terminal = ref_terminal
         return term
 

pyedb/grpc/database/stackup.py

@@ -1355,7 +1355,7 @@ class Stackup(LayerCollection):
         _offset_y = Value(offset_y)
 
         if edb_cell.name not in self._pedb.cell_names:
-            list_cells = self._pedb.copy_cells([edb_cell.api_object])
+            list_cells = self._pedb.copy_cells([edb_cell])
             edb_cell = list_cells[0]
         self._pedb.layout.cell.is_blackbox = True
         cell_inst2 = GrpcCellInstance.create(

pyedb/grpc/database/terminal/bundle_terminal.py

@@ -152,7 +152,7 @@ class BundleTerminal(GrpcBundleTerminal):
         -------
         :class:`Terminal <pyedb.grpc.database.terminal.terminal.Terminal>`
         """
-        return Terminal(self._pedb, self.reference_terminal)
+        return Terminal(self._pedb, super().reference_terminal)
 
     @reference_terminal.setter
     def reference_terminal(self, value):

pyedb/grpc/database/terminal/padstack_instance_terminal.py

@@ -26,7 +26,7 @@ from ansys.edb.core.terminal.padstack_instance_terminal import (
 from ansys.edb.core.terminal.terminal import BoundaryType as GrpcBoundaryType
 
 from pyedb.grpc.database.utility.value import Value
-from pyedb.misc.misc import deprecated_property
+from pyedb.misc.decorators import deprecated_property
 
 
 class PadstackInstanceTerminal(GrpcPadstackInstanceTerminal):

pyedb/grpc/database/terminal/pingroup_terminal.py

@@ -27,7 +27,7 @@ from ansys.edb.core.terminal.terminal import BoundaryType as GrpcBoundaryType
 
 from pyedb.grpc.database.net.net import Net
 from pyedb.grpc.database.utility.value import Value
-from pyedb.misc.misc import deprecated_property
+from pyedb.misc.decorators import deprecated_property
 
 
 class PinGroupTerminal(GrpcPinGroupTerminal):

pyedb/grpc/database/utility/value.py

@@ -19,6 +19,7 @@
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
+
 import ansys.edb.core.utility.value
 from ansys.edb.core.utility.value import Value as GrpcValue
 

pyedb/grpc/database/utility/xml_control_file.py

@@ -26,8 +26,8 @@ import re
 import subprocess
 import sys
 
-from pyedb.edb_logger import pyedb_logger
 from pyedb.generic.general_methods import ET, env_path, env_value, is_linux
+from pyedb.generic.settings import settings
 from pyedb.misc.aedtlib_personalib_install import write_pretty_xml
 from pyedb.misc.misc import list_installed_ansysem
 
@@ -56,7 +56,7 @@ def convert_technology_file(tech_file, edbversion=None, control_file=None):
             base_path = env_path(edbversion)
             sys.path.append(base_path)
         else:
-            pyedb_logger.error("No Edb installation found. Check environment variables")
+            settings.logger.error("No Edb installation found. Check environment variables")
             return False
         os.environ["HELIC_ROOT"] = os.path.join(base_path, "helic")
         if os.getenv("ANSYSLMD_LICENCE_FILE", None) is None:
@@ -69,7 +69,7 @@ def convert_technology_file(tech_file, edbversion=None, control_file=None):
                             os.environ["ANSYSLMD_LICENSE_FILE"] = line.split("=")[1]
                             break
             else:
-                pyedb_logger.error("ANSYSLMD_LICENSE_FILE is not defined.")
+                settings.logger.error("ANSYSLMD_LICENSE_FILE is not defined.")
         vlc_file_name = os.path.splitext(tech_file)[0]
         if not control_file:
             control_file = vlc_file_name + ".xml"
@@ -103,9 +103,9 @@ def convert_technology_file(tech_file, edbversion=None, control_file=None):
             p = subprocess.Popen(command, env=my_env)
             p.wait()
         if os.path.exists(control_file):
-            pyedb_logger.info("Xml file created.")
+            settings.logger.info("Xml file created.")
             return control_file
-    pyedb_logger.error("Technology files are supported only in Linux. Use control file instead.")
+    settings.logger.error("Technology files are supported only in Linux. Use control file instead.")
     return False