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

pyedb/grpc/database/net/differential_pair.py

@@ -0,0 +1,138 @@
+# Copyright (C) 2023 - 2024 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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 re
+
+from ansys.edb.core.net.differential_pair import (
+    DifferentialPair as GrpcDifferentialPair,
+)
+
+from pyedb.grpc.database.net.net import Net
+
+
+class DifferentialPairs:
+    def __init__(self, pedb):
+        self._pedb = pedb
+
+    @property
+    def items(self):
+        """Extended nets.
+
+        Returns
+        -------
+        dict[str, :class:`pyedb.dotnet.database.edb_data.nets_data.EDBDifferentialPairData`]
+            Dictionary of extended nets.
+        """
+        diff_pairs = {}
+        for diff_pair in self._pedb.layout.differential_pairs:
+            diff_pairs[diff_pair.name] = DifferentialPair(self._pedb, diff_pair)
+        return diff_pairs
+
+    def create(self, name, net_p, net_n):
+        # type: (str, str, str) -> DifferentialPair
+        """
+
+        Parameters
+        ----------
+        name : str
+            Name of the differential pair.
+        net_p : str
+            Name of the positive net.
+        net_n : str
+            Name of the negative net.
+
+        Returns
+        -------
+        :class:`pyedb.dotnet.database.edb_data.nets_data.EDBDifferentialPairData`
+        """
+        if name in self.items:
+            self._pedb.logger.error("{} already exists.".format(name))
+            return False
+        GrpcDifferentialPair.create(layout=self._pedb.layout, name=name, pos_net=net_p, neg_net=net_n)
+        return self.items[name]
+
+    def auto_identify(self, positive_differentiator="_P", negative_differentiator="_N"):
+        """Auto identify differential pairs by naming conversion.
+
+        Parameters
+        ----------
+        positive_differentiator: str, optional
+            Differentiator of the positive net. The default is ``"_P"``.
+        negative_differentiator: str, optional
+            Differentiator of the negative net. The default is ``"_N"``.
+
+        Returns
+        -------
+        list
+            A list containing identified differential pair names.
+        Examples
+        --------
+        >>> from pyedb import Edb
+        >>> edbapp = Edb("myaedbfolder", edbversion="2023.1")
+        >>> edb_nets = edbapp.differential_pairs.auto_identify()
+        """
+        nets = self._pedb.nets.nets
+        pos_net = []
+        neg_net = []
+        for name, _ in nets.items():
+            if name.endswith(positive_differentiator):
+                pos_net.append(name)
+            elif name.endswith(negative_differentiator):
+                neg_net.append(name)
+            else:
+                pass
+
+        temp = []
+        for p in pos_net:
+            pattern_p = r"^(.+){}$".format(positive_differentiator)
+            match_p = re.findall(pattern_p, p)[0]
+
+            for n in neg_net:
+                pattern_n = r"^(.+){}$".format(negative_differentiator)
+                match_n = re.findall(pattern_n, n)[0]
+
+                if match_p == match_n:
+                    diff_name = "DIFF_{}".format(match_p)
+                    self.create(diff_name, p, n)
+                    temp.append(diff_name)
+        return temp
+
+
+class DifferentialPair(GrpcDifferentialPair):
+    """Manages EDB functionalities for a primitive.
+    It inherits EDB object properties.
+    """
+
+    def __init__(self, pedb, edb_object):
+        super().__init__(edb_object.msg)
+        self._pedb = pedb
+
+    @property
+    def positive_net(self):
+        """Positive Net."""
+        return Net(self._pedb, super().positive_net)
+
+    @property
+    def negative_net(self):
+        """Negative Net."""
+        return Net(self._pedb, super().negative_net)

pyedb/grpc/database/net/extended_net.py

@@ -0,0 +1,340 @@
+# Copyright (C) 2023 - 2024 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+
+from ansys.edb.core.net.extended_net import ExtendedNet as GrpcExtendedNet
+
+from pyedb.grpc.database.net.net import Net
+
+
+class ExtendedNets:
+    def __init__(self, pedb):
+        self._pedb = pedb
+
+    @property
+    def items(self):
+        """Extended nets.
+
+        Returns
+        -------
+        Dict[str, :class:`ExtendedNet <pyedb.grpc.database.net.extended_net.ExtendedNet>`]
+            Dictionary of extended nets.
+        """
+        nets = {}
+        for extended_net in self._pedb.layout.extended_nets:
+            nets[extended_net.name] = ExtendedNet(self._pedb, extended_net)
+        return nets
+
+    def create(self, name, net):
+        # type: (str, str|list)->ExtendedNet
+        """Create a new Extended net.
+
+        Parameters
+        ----------
+        name : str
+            Name of the extended net.
+        net : str, list
+           Name of the nets to be added into this extended net.
+
+        Returns
+        -------
+        :class:`ExtendedNet <pyedb.grpc.database.net.extended_net.ExtendedNet>`
+            Created ExtendedNet object.
+        """
+        if name in self.items:
+            self._pedb.logger.error("{} already exists.".format(name))
+            return False
+        extended_net = GrpcExtendedNet.create(self._pedb.layout, name)
+        if isinstance(net, str):
+            net = [net]
+        for i in net:
+            extended_net.add_net(self._pedb.nets.nets[i])
+        return self.items[name]
+
+    def auto_identify_signal(self, resistor_below=10, inductor_below=1, capacitor_above=1e-9, exception_list=None):
+        # type: (int | float, int | float, int |float, list) -> list
+        """Get extended signal net and associated components.
+
+        Parameters
+        ----------
+        resistor_below : int, float, optional
+            Threshold for the resistor value. Search the extended net across resistors that
+            have a value lower than the threshold.
+        inductor_below : int, float, optional
+            Threshold for the inductor value. Search the extended net across inductances
+            that have a value lower than the threshold.
+        capacitor_above : int, float, optional
+            Threshold for the capacitor value. Search the extended net across capacitors
+            that have a value higher than the threshold.
+        exception_list : list, optional
+            List of components to bypass when performing threshold checks. Components
+            in the list are considered as serial components. The default is ``None``.
+
+        Returns
+        -------
+        List[:class:`ExtendedNet <pyedb.grpc.database.net.extended_net.ExtendedNet>`]
+            List of all extended nets.
+
+        Examples
+        --------
+        >>> from pyedb import Edb
+        >>> app = Edb()
+        >>> app.extended_nets.auto_identify_signal()
+        """
+        return self.generate_extended_nets(resistor_below, inductor_below, capacitor_above, exception_list, True, True)
+
+    def auto_identify_power(self, resistor_below=10, inductor_below=1, capacitor_above=1, exception_list=None):
+        # type: (int | float, int | float, int |float, list) -> list
+        """Get all extended power nets and their associated components.
+
+        Parameters
+        ----------
+        resistor_below : int, float, optional
+            Threshold for the resistor value. Search the extended net across resistors that
+            have a value lower than the threshold.
+        inductor_below : int, float, optional
+            Threshold for the inductor value. Search the extended net across inductances that
+            have a value lower than the threshold.
+        capacitor_above : int, float, optional
+            Threshold for the capacitor value. Search the extended net across capacitors that
+            have a value higher than the threshold.
+        exception_list : list, optional
+            List of components to bypass when performing threshold checks. Components
+            in the list are considered as serial components. The default is ``None``.
+
+        Returns
+        -------
+        List[:class:`ExtendedNet <pyedb.grpc.database.net.extended_net.ExtendedNet>`]
+            List of all extended nets and their associated components.
+
+        Examples
+        --------
+        >>> from pyedb import Edb
+        >>> app = Edb()
+        >>> app.extended_nets.auto_identify_power()
+        """
+        return self.generate_extended_nets(resistor_below, inductor_below, capacitor_above, exception_list, True, True)
+
+    def generate_extended_nets(
+        self,
+        resistor_below=10,
+        inductor_below=1,
+        capacitor_above=1,
+        exception_list=None,
+        include_signal=True,
+        include_power=True,
+    ):
+        # type: (int | float, int | float, int |float, list, bool, bool) -> list
+        """Get extended net and associated components.
+
+        Parameters
+        ----------
+        resistor_below : int, float, optional
+            Threshold of resistor value. Search extended net across resistors which has value lower than the threshold.
+        inductor_below : int, float, optional
+            Threshold of inductor value. Search extended net across inductances which has value lower than the
+            threshold.
+        capacitor_above : int, float, optional
+            Threshold of capacitor value. Search extended net across capacitors which has value higher than the
+            threshold.
+        exception_list : list, optional
+            List of components to bypass when performing threshold checks. Components
+            in the list are considered as serial components. The default is ``None``.
+        include_signal : str, optional
+            Whether to generate extended signal nets. The default is ``True``.
+        include_power : str, optional
+            Whether to generate extended power nets. The default is ``True``.
+
+        Returns
+        -------
+        List[:class:`ExtendedNet <pyedb.grpc.database.net.extended_net.ExtendedNet>`]
+            List of all extended nets.
+
+        Examples
+        --------
+        >>> from pyedb import Edb
+        >>> app = Edb()
+        >>> app.nets.get_extended_nets()
+        """
+        if exception_list is None:
+            exception_list = []
+        _extended_nets = []
+        _nets = self._pedb.nets.nets
+        all_nets = list(_nets.keys())[:]
+        net_dicts = (
+            self._pedb.nets._comps_by_nets_dict
+            if self._pedb.nets._comps_by_nets_dict
+            else (self._pedb.nets.components_by_nets)
+        )
+        comp_dict = (
+            self._pedb.nets._nets_by_comp_dict
+            if self._pedb.nets._nets_by_comp_dict
+            else (self._pedb.nets.nets_by_components)
+        )
+
+        def get_net_list(net_name, _net_list):
+            comps = []
+            if net_name in net_dicts:
+                comps = net_dicts[net_name]
+
+            for vals in comps:
+                refdes = vals
+                cmp = self._pedb.components.instances[refdes]
+                if cmp.type not in ["inductor", "resistor", "capacitor"]:
+                    continue
+                if not cmp.enabled:
+                    continue
+                val_value = cmp.rlc_values
+                if refdes in exception_list:
+                    pass
+                elif cmp.type == "inductor" and val_value[1] < inductor_below:
+                    pass
+                elif cmp.type == "resistor" and val_value[0] < resistor_below:
+                    pass
+                elif cmp.type == "capacitor" and val_value[2] > capacitor_above:
+                    pass
+                else:
+                    continue
+                for net in comp_dict[refdes]:
+                    if net not in _net_list:
+                        _net_list.append(net)
+                        get_net_list(net, _net_list)
+
+        while len(all_nets) > 0:
+            new_ext = [all_nets[0]]
+            get_net_list(new_ext[0], new_ext)
+            all_nets = [i for i in all_nets if i not in new_ext]
+            _extended_nets.append(new_ext)
+
+            if len(new_ext) > 1:
+                i = new_ext[0]
+                for i in new_ext:
+                    if not i.lower().startswith("unnamed"):
+                        break
+
+                is_power = False
+                for i in new_ext:
+                    is_power = is_power or _nets[i].is_power_ground
+
+                if is_power:
+                    if include_power:
+                        ext_net = ExtendedNet.create(self._pedb.layout, i)
+                        ext_net.add_net(self._pedb.nets.nets[i])
+                        for net in new_ext:
+                            ext_net.add_net(self._pedb.nets.nets[net])
+                    else:  # pragma: no cover
+                        pass
+                else:
+                    if include_signal:
+                        ext_net = ExtendedNet.create(self._pedb.layout, i)
+                        ext_net.add_net(self._pedb.nets.nets[i])
+                        for net in new_ext:
+                            ext_net.add_net(self._pedb.nets.nets[net])
+                    else:  # pragma: no cover
+                        pass
+
+        return _extended_nets
+
+
+class ExtendedNet(GrpcExtendedNet):
+    """Manages EDB functionalities for a primitives.
+    It Inherits EDB Object properties.
+    """
+
+    def __init__(self, pedb, edb_object):
+        super().__init__(edb_object.msg)
+        self._pedb = pedb
+
+    @property
+    def nets(self):
+        """Nets dictionary.
+
+        Returns
+        -------
+        Dict[str, :class:`Net <pyedb.grpc.database.net.net.Net>`]
+            Dict[net name, Net object].
+        """
+        return {net.name: Net(self._pedb, net) for net in super().nets}
+
+    @property
+    def components(self):
+        """Dictionary of components.
+
+        Returns
+        -------
+        Dict[str, :class:`Component <pyedb.grpc.database.hierarchy.component.Component>`].
+            Dict[net name, Component object].
+        """
+        comps = {}
+        for _, obj in self.nets.items():
+            comps.update(obj.components)
+        return comps
+
+    @property
+    def rlc(self):
+        """Dictionary of RLC components.
+
+        Returns
+        -------
+        Dict[str, :class:`Component <pyedb.grpc.database.hierarchy.component.Component>`].
+            Dict[net name, Component object].
+        """
+        return {
+            name: comp for name, comp in self.components.items() if comp.type in ["inductor", "resistor", "capacitor"]
+        }
+
+    @property
+    def serial_rlc(self):
+        """Dictionary of serial RLC components.
+
+        Returns
+        -------
+        Dict[str, :class:`Component <pyedb.grpc.database.hierarchy.component.Component>`].
+            Dict[net name, Component object].
+
+        """
+        res = {}
+        nets = self.nets
+        for comp_name, comp_obj in self.components.items():
+            if comp_obj.type not in ["resistor", "inductor", "capacitor"]:
+                continue
+            if set(list(nets.keys())).issubset(comp_obj.nets):
+                res[comp_name] = comp_obj
+        return res
+
+    @property
+    def shunt_rlc(self):
+        """Dictionary of shunt RLC components.
+
+        Returns
+        -------
+        Dict[str, :class:`Component <pyedb.grpc.database.hierarchy.component.Component>`].
+            Dict[net name, Component object].
+
+        """
+        res = {}
+        nets = self.nets
+        for comp_name, comp_obj in self.components.items():
+            if comp_obj.type not in ["resistor", "inductor", "capacitor"]:
+                continue
+            if not set(list(nets.keys())).issubset(comp_obj.nets):
+                res[comp_name] = comp_obj
+        return res

pyedb/grpc/database/net/net.py

@@ -0,0 +1,198 @@
+# Copyright (C) 2023 - 2024 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+
+from ansys.edb.core.net.net import Net as GrpcNet
+from ansys.edb.core.primitive.primitive import PrimitiveType as GrpcPrimitiveType
+
+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
+
+
+class Net(GrpcNet):
+    """Manages EDB functionalities for a primitives.
+    It Inherits EDB Object properties.
+
+    Examples
+    --------
+    >>> from pyedb import Edb
+    >>> edb = Edb(myedb, edbversion="2021.2")
+    >>> edb_net = edb.nets.nets["GND"]
+    >>> edb_net.name # Class Property
+    >>> edb_net.name # EDB Object Property
+    """
+
+    def __init__(self, pedb, raw_net):
+        super().__init__(raw_net.msg)
+        self._pedb = pedb
+        self._core_components = pedb.components
+        self._core_primitive = pedb.modeler
+        self._edb_object = raw_net
+
+    @property
+    def primitives(self):
+        """Primitives that belongs to the net.
+
+        Returns
+        -------
+        List[:class:`Primitive <pyedb.grpc.database.primitive.primitive.Primitive>`].
+            List of Primitive object.
+
+        """
+        primitives = []
+        for primitive in super().primitives:
+            if primitive.primitive_type == GrpcPrimitiveType.PATH:
+                primitives.append(Path(self._pedb, primitive))
+            elif primitive.primitive_type == GrpcPrimitiveType.POLYGON:
+                primitives.append(Polygon(self._pedb, primitive))
+            elif primitive.primitive_type == GrpcPrimitiveType.CIRCLE:
+                primitives.append(Circle(self._pedb, primitive))
+            elif primitive.primitive_type == GrpcPrimitiveType.RECTANGLE:
+                primitives.append(Rectangle(self._pedb, primitive))
+            elif primitive.primitive_type == GrpcPrimitiveType.BONDWIRE:
+                primitives.append(Bondwire(self._pedb, primitive))
+        return primitives
+
+    @property
+    def padstack_instances(self):
+        """Padstack instance which belong to net.
+
+        Returns
+        -------
+        List[:class:`PadstackInstance <pyedb.grpc.database.primitive.padstack_instance.PadstackInstance>`]
+            LIst of PadstackInstance object.
+
+        """
+        return [PadstackInstance(self._pedb, i) for i in super().padstack_instances]
+
+    @property
+    def components(self):
+        """Components connected to net.
+
+        Returns
+        -------
+        Dict[str, :class:`Component <pyedb.grpc.database.hierarchy.component.Component>`]
+        """
+        components = {}
+        for padstack_instance in self.padstack_instances:
+            component = padstack_instance.component
+            if component:
+                try:
+                    components[component.name] = component
+                except:
+                    pass
+        return components
+
+    def find_dc_short(self, fix=False):
+        """Find DC-shorted nets.
+
+        Parameters
+        ----------
+        fix : bool, optional
+            If `True`, rename all the nets. (default)
+            If `False`, only report dc shorts.
+
+        Returns
+        -------
+        List[List[str, str]]
+            [[net name, net name]].
+        """
+        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,
+    ):
+        """Plot a net to Matplotlib 2D chart.
+
+        Parameters
+        ----------
+        layers : str, list, optional
+            Name of the layers to include in the plot. If `None` all the signal layers will be considered.
+        show_legend : bool, optional
+            If `True` the legend is shown in the plot. (default)
+            If `False` the legend is not shown.
+        save_plot : str, optional
+            If a path is specified the plot will be saved in this location.
+            If ``save_plot`` is provided, the ``show`` parameter is ignored.
+        outline : list, optional
+            List of points of the outline to plot.
+        size : tuple, optional
+            Image size in pixel (width, height).
+        show : bool, optional
+            Whether to show the plot or not. Default is `True`.
+        """
+
+        self._pedb.nets.plot(
+            self.name,
+            layers=layers,
+            show_legend=show_legend,
+            save_plot=save_plot,
+            outline=outline,
+            size=size,
+            show=show,
+            plot_components=True,
+            plot_vias=True,
+        )
+
+    def get_smallest_trace_width(self):
+        """Retrieve the smallest trace width from paths.
+
+        Returns
+        -------
+        float
+            Trace smallest width.
+        """
+
+        current_value = 1e10
+        paths = [prim for prim in self.primitives if prim.primitive_type == GrpcPrimitiveType.PATH]
+        for path in paths:
+            if path.width < current_value:
+                current_value = path.width
+        return current_value
+
+    @property
+    def extended_net(self):
+        """Get extended net and associated components.
+
+        Returns
+        -------
+        :class:`ExtendedNet <pyedb.grpc.database.net.extended_net.ExtendedNet>`
+
+        Examples
+        --------
+        >>> from pyedb import Edb
+        >>> app = Edb()
+        >>> app.nets["BST_V3P3_S5"].extended_net
+        """
+        if self.name in self._pedb.extended_nets.items:
+            return self._pedb.extended_nets.items[self.name]
+        else:
+            return None