pyedb 0.17.0__py3-none-any.whl → 0.19.0__py3-none-any.whl

pyedb/configuration/configuration.py

@@ -65,14 +65,16 @@ class Configuration:
         """
         if isinstance(config_file, dict):
             data = config_file
-        elif os.path.isfile(config_file):
-            with open(config_file, "r") as f:
-                if config_file.endswith(".json"):
-                    data = json.load(f)
-                elif config_file.endswith(".toml"):
-                    data = toml.load(f)
-        else:  # pragma: no cover
-            return False
+        else:
+            config_file = str(config_file)
+            if os.path.isfile(config_file):
+                with open(config_file, "r") as f:
+                    if config_file.endswith(".json"):
+                        data = json.load(f)
+                    elif config_file.endswith(".toml"):
+                        data = toml.load(f)
+            else:  # pragma: no cover
+                return False
 
         if not append:  # pragma: no cover
             self.data = {}
@@ -120,16 +122,13 @@ class Configuration:
             self.cfg_data.padstacks.apply()
 
         # Configure pin groups
-        for pin_group in self.cfg_data.pin_groups:
-            pin_group.apply()
+        self.cfg_data.pin_groups.apply()
 
         # Configure ports
-        for port in self.cfg_data.ports:
-            port.create()
+        self.cfg_data.ports.apply()
 
         # Configure sources
-        for source in self.cfg_data.sources:
-            source.create()
+        self.cfg_data.sources.apply()
 
         # Configure setup
         self.cfg_data.setups.apply()
@@ -271,12 +270,30 @@ class Configuration:
             data["package_definitions"] = self.cfg_data.package_definitions.get_data_from_db()
         if kwargs.get("setups", False):
             data["setups"] = self.cfg_data.setups.get_data_from_db()
+        if kwargs.get("sources", False):
+            data["sources"] = self.cfg_data.sources.get_data_from_db()
+        if kwargs.get("ports", False):
+            data["ports"] = self.cfg_data.ports.get_data_from_db()
         if kwargs.get("components", False):
             data["components"] = self.cfg_data.components.get_data_from_db()
+        if kwargs.get("nets", False):
+            data["nets"] = self.cfg_data.nets.get_data_from_db()
+        if kwargs.get("pin_groups", False):
+            data["pin_groups"] = self.cfg_data.pin_groups.get_data_from_db()
 
         return data
 
-    def export(self, file_path, stackup=True, package_definitions=True, setups=True):
+    def export(
+        self,
+        file_path,
+        stackup=True,
+        package_definitions=True,
+        setups=True,
+        sources=True,
+        ports=True,
+        nets=True,
+        pin_groups=True,
+    ):
         """Export the configuration data from layout to a file.
 
         Parameters
@@ -285,14 +302,31 @@ class Configuration:
             File path to export the configuration data.
         stackup : bool
             Whether to export stackup or not.
-
+        package_definitions : bool
+            Whether to export package definitions or not.
+        setups : bool
+            Whether to export setups or not.
+        sources : bool
+            Whether to export sources or not.
+        ports : bool
+            Whether to export ports or not.
+        nets : bool
+            Whether to export nets.
         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, setups=setups)
+        data = self.get_data_from_db(
+            stackup=stackup,
+            package_definitions=package_definitions,
+            setups=setups,
+            sources=sources,
+            ports=ports,
+            nets=nets,
+            pin_groups=pin_groups,
+        )
         with open(file_path, "w") as f:
             json.dump(data, f, ensure_ascii=False, indent=4)
         return True if os.path.isfile(file_path) else False

pyedb/dotnet/edb.py

@@ -510,6 +510,7 @@ class Edb(Database):
     def sources(self):
         """Get all layout sources."""
         terms = [term for term in self.layout.terminals if int(term.GetBoundaryType()) in [3, 4, 7]]
+        terms = [term for term in terms if not term.IsReferenceTerminal()]
         return {ter.GetName(): ExcitationSources(self, ter) for ter in terms}
 
     @property
@@ -1558,6 +1559,7 @@ class Edb(Database):
         reference_list=[],
         include_pingroups=True,
         pins_to_preserve=None,
+        inlcude_voids_in_extents=False,
     ):
         if extent_type in [
             "Conforming",
@@ -1574,6 +1576,7 @@ class Edb(Database):
                     smart_cut,
                     reference_list,
                     pins_to_preserve,
+                    inlcude_voids_in_extents=inlcude_voids_in_extents,
                 )
             else:
                 _poly = self.layout.expanded_extent(
@@ -1632,6 +1635,7 @@ class Edb(Database):
         smart_cutout=False,
         reference_list=[],
         pins_to_preserve=None,
+        inlcude_voids_in_extents=False,
     ):
         names = []
         _polys = []
@@ -1649,7 +1653,7 @@ class Edb(Database):
 
         for prim in self.modeler.primitives:
             if prim is not None and prim.net_name in names:
-                _polys.append(prim.primitive_object.GetPolygonData())
+                _polys.append(prim)
         if smart_cutout:
             objs_data = self._smart_cut(reference_list, expansion_size)
             _polys.extend(objs_data)
@@ -1658,9 +1662,33 @@ class Edb(Database):
         while k < 10:
             unite_polys = []
             for i in _polys:
-                obj_data = i.Expand(expansion_size, tolerance, round_corner, round_extension)
+                if "PolygonData" not in str(i):
+                    obj_data = i.primitive_object.GetPolygonData().Expand(
+                        expansion_size, tolerance, round_corner, round_extension
+                    )
+                else:
+                    obj_data = i.Expand(expansion_size, tolerance, round_corner, round_extension)
                 if obj_data:
-                    unite_polys.extend(list(obj_data))
+                    if not inlcude_voids_in_extents:
+                        unite_polys.extend(list(obj_data))
+                    else:
+                        voids_poly = []
+                        try:
+                            if i.HasVoids():
+                                area = i.area()
+                                for void in i.Voids:
+                                    void_polydata = void.GetPolygonData()
+                                    if void_polydata.Area() >= 0.05 * area:
+                                        voids_poly.append(void_polydata)
+                                if voids_poly:
+                                    obj_data = obj_data[0].Subtract(
+                                        convert_py_list_to_net_list(list(obj_data)),
+                                        convert_py_list_to_net_list(voids_poly),
+                                    )
+                        except:
+                            pass
+                        finally:
+                            unite_polys.extend(list(obj_data))
             _poly_unite = self.edb_api.geometry.polygon_data.unite(unite_polys)
             if len(_poly_unite) == 1:
                 self.logger.info("Correctly computed Extension at first iteration.")
@@ -1761,6 +1789,7 @@ class Edb(Database):
         preserve_components_with_model=False,
         simple_pad_check=True,
         keep_lines_as_path=False,
+        include_voids_in_extents=False,
     ):
         """Create a cutout using an approach entirely based on PyAEDT.
         This method replaces all legacy cutout methods in PyAEDT.
@@ -1837,6 +1866,11 @@ class Edb(Database):
             This feature works only in Electronics Desktop (3D Layout).
             If the flag is set to ``True`` it can cause issues in SiWave once the Edb is imported.
             Default is ``False`` to generate PolygonData of cut lines.
+        include_voids_in_extents : bool, optional
+            Whether to compute and include voids in pyaedt extent before the cutout. Cutout time can be affected.
+            It works only with Conforming cutout.
+            Default is ``False`` to generate extent without voids.
+
 
         Returns
         -------
@@ -1896,6 +1930,7 @@ class Edb(Database):
                 use_pyaedt_extent_computing=use_pyaedt_extent_computing,
                 check_terminals=check_terminals,
                 include_pingroups=include_pingroups,
+                inlcude_voids_in_extents=include_voids_in_extents,
             )
         else:
             legacy_path = self.edbpath
@@ -1929,6 +1964,7 @@ class Edb(Database):
                         include_partial=include_partial_instances,
                         simple_pad_check=simple_pad_check,
                         keep_lines_as_path=keep_lines_as_path,
+                        inlcude_voids_in_extents=include_voids_in_extents,
                     )
                     if self.are_port_reference_terminals_connected():
                         if output_aedb_path:
@@ -1969,6 +2005,7 @@ class Edb(Database):
                     include_partial=include_partial_instances,
                     simple_pad_check=simple_pad_check,
                     keep_lines_as_path=keep_lines_as_path,
+                    inlcude_voids_in_extents=include_voids_in_extents,
                 )
             if result and not open_cutout_at_end and self.edbpath != legacy_path:
                 self.save_edb()
@@ -1990,6 +2027,7 @@ class Edb(Database):
         remove_single_pin_components=False,
         check_terminals=False,
         include_pingroups=True,
+        inlcude_voids_in_extents=False,
     ):
         expansion_size = self.edb_value(expansion_size).ToDouble()
 
@@ -2010,8 +2048,14 @@ class Edb(Database):
             smart_cut=check_terminals,
             reference_list=reference_list,
             include_pingroups=include_pingroups,
+            inlcude_voids_in_extents=inlcude_voids_in_extents,
         )
-
+        _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)
+        _poly = _poly1
         # Create new cutout cell/design
         included_nets_list = signal_list + reference_list
         included_nets = convert_py_list_to_net_list(
@@ -2172,6 +2216,7 @@ class Edb(Database):
         include_partial=False,
         simple_pad_check=True,
         keep_lines_as_path=False,
+        inlcude_voids_in_extents=False,
     ):
         if is_ironpython:  # pragma: no cover
             self.logger.error("Method working only in Cpython")
@@ -2269,11 +2314,18 @@ class Edb(Database):
                 reference_list=reference_list,
                 include_pingroups=include_pingroups,
                 pins_to_preserve=pins_to_preserve,
+                inlcude_voids_in_extents=inlcude_voids_in_extents,
             )
             if extent_type in ["Conforming", self.edb_api.geometry.extent_type.Conforming, 1]:
                 if extent_defeature > 0:
                     _poly = _poly.Defeature(extent_defeature)
-                _poly = _poly.CreateFromArcs(_poly.GetArcData(), True)
+
+                _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)
+                _poly = _poly1
         if not _poly or _poly.IsNull():
             self._logger.error("Failed to create Extent.")
             return []
@@ -2312,29 +2364,39 @@ class Edb(Database):
             pdata = prim_1.polygon_data.edb_api
             int_data = _poly.GetIntersectionType(pdata)
             if int_data == 2:
-                return
+                if not inlcude_voids_in_extents:
+                    return
+                skip = False
+                for hole in list(_poly.Holes):
+                    if hole.GetIntersectionType(pdata) == 0:
+                        prims_to_delete.append(prim_1)
+                        return
+                    elif hole.GetIntersectionType(pdata) == 1:
+                        skip = True
+                if skip:
+                    return
             elif int_data == 0:
                 prims_to_delete.append(prim_1)
-            else:
-                list_poly = intersect(_poly, pdata)
-                if list_poly:
-                    net = prim_1.net_name
-                    voids = prim_1.voids
-                    for p in list_poly:
-                        if p.IsNull():
-                            continue
-                        # points = list(p.Points)
-                        list_void = []
-                        if voids:
-                            voids_data = [void.polygon_data.edb_api for void in voids]
-                            list_prims = subtract(p, voids_data)
-                            for prim in list_prims:
-                                if not prim.IsNull():
-                                    poly_to_create.append([prim, prim_1.layer.name, net, list_void])
-                        else:
-                            poly_to_create.append([p, prim_1.layer.name, net, list_void])
+                return
+            list_poly = intersect(_poly, pdata)
+            if list_poly:
+                net = prim_1.net_name
+                voids = prim_1.voids
+                for p in list_poly:
+                    if p.IsNull():
+                        continue
+                    # points = list(p.Points)
+                    list_void = []
+                    if voids:
+                        voids_data = [void.polygon_data.edb_api for void in voids]
+                        list_prims = subtract(p, voids_data)
+                        for prim in list_prims:
+                            if not prim.IsNull():
+                                poly_to_create.append([prim, prim_1.layer.name, net, list_void])
+                    else:
+                        poly_to_create.append([p, prim_1.layer.name, net, list_void])
 
-                prims_to_delete.append(prim_1)
+            prims_to_delete.append(prim_1)
 
         def pins_clean(pinst):
             if not pinst.in_polygon(_poly, include_partial=include_partial, simple_check=simple_pad_check):
@@ -2350,7 +2412,9 @@ class Edb(Database):
         for pin in pins_to_delete:
             pin.delete()
 
-        self.logger.info_timer("Padstack Instances removal completed")
+        self.logger.info_timer(
+            "Padstack Instances removal completed. {} instances removed.".format(len(pins_to_delete))
+        )
         self.logger.reset_timer()
 
         # with ThreadPoolExecutor(number_of_threads) as pool:
@@ -2369,7 +2433,7 @@ class Edb(Database):
         for prim in prims_to_delete:
             prim.delete()
 
-        self.logger.info_timer("Primitives cleanup completed")
+        self.logger.info_timer("Primitives cleanup completed. {} primitives deleted.".format(len(prims_to_delete)))
         self.logger.reset_timer()
 
         i = 0
@@ -3680,7 +3744,7 @@ class Edb(Database):
         if float(self.edbversion) < 2024.2:
             self.logger.error("HFSSPI simulation only supported with Ansys release 2024R2 and higher")
             return False
-        return HFSSPISimulationSetup(self).create(name)
+        return HFSSPISimulationSetup(self, name=name)
 
     def create_siwave_syz_setup(self, name=None, **kwargs):
         """Create a setup from a template.

pyedb/dotnet/edb_core/cell/layout.py

@@ -23,9 +23,11 @@
 """
 This module contains these classes: `EdbLayout` and `Shape`.
 """
-
 from pyedb.dotnet.edb_core.cell.primitive import Bondwire
 from pyedb.dotnet.edb_core.edb_data.nets_data import EDBNetsData
+from pyedb.dotnet.edb_core.edb_data.padstacks_data import EDBPadstackInstance
+from pyedb.dotnet.edb_core.edb_data.sources import PinGroup
+from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
 from pyedb.dotnet.edb_core.layout import EdbLayout
 
 
@@ -65,6 +67,11 @@ class Layout(EdbLayout):
             if i.GetPrimitiveType().ToString() == "Bondwire"
         ]
 
+    @property
+    def padstack_instances(self):
+        """Get all padstack instances in a list."""
+        return [EDBPadstackInstance(i, self._pedb) for i in self._edb_object.PadstackInstances]
+
     def create_bondwire(
         self,
         definition_name,
@@ -129,3 +136,43 @@ class Layout(EdbLayout):
             end_y=self._pedb.edb_value(end_y),
             net=self.nets[net]._edb_object,
         )
+
+    def find_object_by_id(self, value: int):
+        """Find a Connectable object by Database ID.
+
+        Parameters
+        ----------
+        value : int
+        """
+        obj = self._pedb._edb.Cell.Connectable.FindById(self._edb_object, value)
+        if obj.GetObjType().ToString() == "PadstackInstance":
+            return EDBPadstackInstance(obj, self._pedb)
+
+    def create_pin_group(self, name: str, pins_by_id: list[int] = None, pins_by_aedt_name: list[str] = None):
+        """Create a PinGroup.
+
+        Parameters
+        name : str,
+            Name of the PinGroup.
+        pins_by_id : list[int] or None
+            List of pins by ID.
+        pins_by_aedt_name : list[str] or None
+            List of pins by AEDT name.
+        """
+        pins = []
+
+        if pins_by_id is not None:
+            for p in pins_by_id:
+                pins.append(self.find_object_by_id(p._edb_object))
+        else:
+            p_inst = self.padstack_instances
+            while True:
+                p = p_inst.pop(0)
+                if p.aedt_name in pins_by_aedt_name:
+                    pins.append(p._edb_object)
+                    pins_by_aedt_name.remove(p.aedt_name)
+                if len(pins_by_aedt_name) == 0:
+                    break
+
+        obj = self._edb.cell.hierarchy.pin_group.Create(self._edb_object, name, convert_py_list_to_net_list(pins))
+        return PinGroup(name, obj, self._pedb)

pyedb/dotnet/edb_core/cell/terminal/padstack_instance_terminal.py

@@ -86,3 +86,13 @@ class PadstackInstanceTerminal(Terminal):
         terminal = PadstackInstanceTerminal(self._pedb, terminal)
 
         return terminal if not terminal.is_null else False
+
+    def _get_parameters(self):
+        """Gets the parameters of the padstack instance terminal."""
+        _, padstack_inst, layer_obj = self._edb_object.GetParameters()
+        return padstack_inst, layer_obj
+
+    @property
+    def padstack_instance(self):
+        p_inst, _ = self._get_parameters()
+        return self._pedb.modeler.find_object_by_id(p_inst.GetId())

pyedb/dotnet/edb_core/cell/terminal/pingroup_terminal.py

@@ -57,3 +57,8 @@ class PinGroupTerminal(Terminal):
         )
         term = PinGroupTerminal(self._pedb, term)
         return term if not term.is_null else False
+
+    def pin_group(self):
+        """Gets the pin group the terminal refers to."""
+        name = self._edb_object.GetPinGroup().GetName()
+        return self._pedb.siwave.pin_groups[name]

pyedb/dotnet/edb_core/cell/terminal/point_terminal.py

@@ -60,14 +60,3 @@ class PointTerminal(Terminal):
         )
         terminal = PointTerminal(self._pedb, terminal)
         return terminal if not terminal.is_null else False
-
-    @property
-    def ref_terminal(self):
-        """Get reference terminal."""
-
-        terminal = Terminal(self._pedb, self._edb_object.GetReferenceTerminal())
-        return terminal if not terminal.is_null else False
-
-    @ref_terminal.setter
-    def ref_terminal(self, value):
-        self._edb_object.SetReferenceTerminal(value._edb_object)

pyedb/dotnet/edb_core/cell/terminal/terminal.py

@@ -217,6 +217,21 @@ class Terminal(Connectable):
     def boundary_type(self, value):
         self._edb_object.SetBoundaryType(self._boundary_type_mapping[value])
 
+    @property
+    def is_port(self):
+        """Whether it is a port."""
+        return True if self.boundary_type == "PortBoundary" else False
+
+    @property
+    def is_current_source(self):
+        """Whether it is a current source."""
+        return True if self.boundary_type == "kCurrentSource" else False
+
+    @property
+    def is_voltage_source(self):
+        """Whether it is a voltage source."""
+        return True if self.boundary_type == "kVoltageSource" else False
+
     @property
     def impedance(self):
         """Impedance of the port."""
@@ -235,7 +250,8 @@ class Terminal(Connectable):
     def ref_terminal(self):
         """Get reference terminal."""
 
-        terminal = Terminal(self._pedb, self._edb_object.GetReferenceTerminal())
+        edb_terminal = self._edb_object.GetReferenceTerminal()
+        terminal = self._pedb.terminals[edb_terminal.GetName()]
         if not terminal.is_null:
             return terminal
 
@@ -444,3 +460,21 @@ class Terminal(Connectable):
                 pin_obj = pin
         if pin_obj:
             return EDBPadstackInstance(pin_obj, self._pedb)
+
+    @property
+    def magnitude(self):
+        """Get the magnitude of the source."""
+        return self._edb_object.GetSourceAmplitude().ToDouble()
+
+    @magnitude.setter
+    def magnitude(self, value):
+        self._edb_object.SetSourceAmplitude(self._edb.utility.value(value))
+
+    @property
+    def phase(self):
+        """Get the phase of the source."""
+        return self._edb_object.GetSourcePhase().ToDouble()
+
+    @phase.setter
+    def phase(self, value):
+        self._edb_object.SetSourcePhase(self._edb.utility.value(value))