pyedb 0.6.0__py3-none-any.whl → 0.7.1__py3-none-any.whl

pyedb/dotnet/edb_core/edb_data/hfss_extent_info.py

@@ -39,14 +39,14 @@ class HfssExtentInfo:
         self._pedb = pedb
 
         self._hfss_extent_info_type = {
-            "BoundingBox": self._pedb.edb_api.utility.utility.HFSSExtentInfoType.BoundingBox,
-            "Conforming": self._pedb.edb_api.utility.utility.HFSSExtentInfoType.Conforming,
-            "ConvexHull": self._pedb.edb_api.utility.utility.HFSSExtentInfoType.ConvexHull,
-            "Polygon": self._pedb.edb_api.utility.utility.HFSSExtentInfoType.Polygon,
+            "bounding_box": self._pedb.edb_api.utility.utility.HFSSExtentInfoType.BoundingBox,
+            "conforming": self._pedb.edb_api.utility.utility.HFSSExtentInfoType.Conforming,
+            "convexHull": self._pedb.edb_api.utility.utility.HFSSExtentInfoType.ConvexHull,
+            "polygon": self._pedb.edb_api.utility.utility.HFSSExtentInfoType.Polygon,
         }
         self._open_region_type = {
-            "Radiation": self._pedb.edb_api.utility.utility.OpenRegionType.Radiation,
-            "PML": self._pedb.edb_api.utility.utility.OpenRegionType.PML,
+            "radiation": self._pedb.edb_api.utility.utility.OpenRegionType.Radiation,
+            "pml": self._pedb.edb_api.utility.utility.OpenRegionType.PML,
         }
 
     @pyedb_function_handler()
@@ -195,18 +195,19 @@ class HfssExtentInfo:
     @property
     def dielectric_extent_type(self):
         """Dielectric extent type."""
-        return self._edb_hfss_extent_info.DielectricExtentType.ToString()
+        return self._edb_hfss_extent_info.DielectricExtentType.ToString().lower()
 
     @dielectric_extent_type.setter
     def dielectric_extent_type(self, value):
+        value = "bounding_box" if value == "BoundingBox" else value
         info = self._edb_hfss_extent_info
-        info.DielectricExtentType = self._hfss_extent_info_type[value]
+        info.DielectricExtentType = self._hfss_extent_info_type[value.lower()]
         self._update_hfss_extent_info(info)
 
     @property
     def extent_type(self):
         """Extent type."""
-        return self._edb_hfss_extent_info.ExtentType.ToString()
+        return self._edb_hfss_extent_info.ExtentType.ToString().lower()
 
     @extent_type.setter
     def extent_type(self, value):
@@ -239,17 +240,17 @@ class HfssExtentInfo:
     @property
     def open_region_type(self):
         """Open region type."""
-        return self._edb_hfss_extent_info.OpenRegionType.ToString()
+        return self._edb_hfss_extent_info.OpenRegionType.ToString().lower()
 
     @open_region_type.setter
     def open_region_type(self, value):
         info = self._edb_hfss_extent_info
-        info.OpenRegionType = self._open_region_type[value]
+        info.OpenRegionType = self._open_region_type[value.lower()]
         self._update_hfss_extent_info(info)
 
     @property
     def operating_freq(self):
-        """Operating frequency.
+        """PML Operating frequency.
 
         Returns
         -------
@@ -266,7 +267,7 @@ class HfssExtentInfo:
 
     @property
     def radiation_level(self):
-        """Radiation level."""
+        """PML Radiation level to calculate the thickness of boundary."""
         return EdbValue(self._edb_hfss_extent_info.RadiationLevel)
 
     @radiation_level.setter

pyedb/dotnet/edb_core/edb_data/hfss_simulation_setup_data.py

@@ -21,11 +21,11 @@
 # SOFTWARE.
 
 from pyedb.dotnet.clr_module import Tuple
-from pyedb.dotnet.edb_core.edb_data.simulation_setup import (
+from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
+from pyedb.dotnet.edb_core.utilities.simulation_setup import (
     BaseSimulationSetup,
     EdbFrequencySweep,
 )
-from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
 from pyedb.generic.general_methods import generate_unique_name, pyedb_function_handler
 
 

pyedb/dotnet/edb_core/edb_data/layer_data.py

@@ -553,6 +553,7 @@ class StackupLayerEdbClass(LayerEdbClass):
                 dict_out[k[1:]] = v
         return dict_out
 
+    # TODO: This method might need some refactoring
     def _load_layer(self, layer):
         if layer:
             self.color = layer["color"]
@@ -560,13 +561,17 @@ class StackupLayerEdbClass(LayerEdbClass):
             if isinstance(layer["material"], str):
                 self.material = layer["material"]
             else:
-                self._pclass._pedb.materials._load_materials(layer["material"])
-                self.material = layer["material"]["name"]
+                material_data = layer["material"]
+                if material_data is not None:
+                    self._pclass._pedb.materials.add_material(**material_data)
+                    self.material = layer["material"]["name"]
             if layer["dielectric_fill"]:
                 if isinstance(layer["dielectric_fill"], str):
                     self.dielectric_fill = layer["dielectric_fill"]
                 else:
-                    self._pclass._pedb.materials._load_materials(layer["dielectric_fill"])
+                    dielectric_data = layer["dielectric_fill"]
+                    if dielectric_data is not None:
+                        self._pclass._pedb.materials.add_material(**dielectric_data)
                     self.dielectric_fill = layer["dielectric_fill"]["name"]
             self.thickness = layer["thickness"]
             self.etch_factor = layer["etch_factor"]

pyedb/dotnet/edb_core/edb_data/padstacks_data.py

@@ -144,6 +144,11 @@ class EDBPadProperties(object):
         """
         return [i.tofloat for i in self.parameters.values()]
 
+    @property
+    def parameters_values_string(self):
+        """Parameters value in string format."""
+        return [i.tostring for i in self.parameters.values()]
+
     @property
     def polygon_data(self):
         """Parameters.
@@ -499,6 +504,21 @@ class EDBPadstack(object):
         self._hole_parameters = self.hole_params[2]
         return self._hole_parameters
 
+    @property
+    def hole_diameter(self):
+        """Hole diameter."""
+        return list(self.hole_params[2])[0].ToDouble()
+
+    @hole_diameter.setter
+    def hole_diameter(self, value):
+        params = convert_py_list_to_net_list([self._get_edb_value(value)])
+        self._update_hole_parameters(params=params)
+
+    @property
+    def hole_diameter_string(self):
+        """Hole diameter in string format."""
+        return list(self.hole_params[2])[0].ToString()
+
     @pyedb_function_handler()
     def _update_hole_parameters(self, hole_type=None, params=None, offsetx=None, offsety=None, rotation=None):
         """Update hole parameters.
@@ -668,6 +688,7 @@ class EDBPadstack(object):
         float
             Thickness of the hole plating if present.
         """
+        value = self._get_edb_value(value).ToDouble()
         hr = 200 * float(value) / float(self.hole_properties[0])
         self.hole_plating_ratio = hr
 
@@ -788,13 +809,13 @@ class EDBPadstack(object):
         if convert_only_signal_vias:
             signal_nets = [i for i in list(self._ppadstack._pedb.nets.signal_nets.keys())]
         topl, topz, bottoml, bottomz = self._ppadstack._pedb.stackup.stackup_limits(True)
-        try:
+        if self.via_start_layer in layers:
             start_elevation = layers[self.via_start_layer].lower_elevation
-        except KeyError:  # pragma: no cover
+        else:
             start_elevation = layers[self.instances[0].start_layer].lower_elevation
-        try:
-            stop_elevation = layers[self.via_start_layer].upper_elevation
-        except KeyError:  # pragma: no cover
+        if self.via_stop_layer in layers:
+            stop_elevation = layers[self.via_stop_layer].upper_elevation
+        else:
             stop_elevation = layers[self.instances[0].stop_layer].upper_elevation
 
         diel_thick = abs(start_elevation - stop_elevation)

pyedb/dotnet/edb_core/edb_data/primitives_data.py

@@ -142,7 +142,7 @@ class EDBPrimitivesMain(Connectable):
         try:
             layer_name = self.primitive_object.GetLayer().GetName()
             return self._pedb.stackup.layers[layer_name]
-        except AttributeError:  # pragma: no cover
+        except (KeyError, AttributeError):  # pragma: no cover
             return None
 
     @property
@@ -155,18 +155,19 @@ class EDBPrimitivesMain(Connectable):
         """
         try:
             return self.layer.name
-        except AttributeError:  # pragma: no cover
+        except (KeyError, AttributeError):  # pragma: no cover
             return None
 
     @layer_name.setter
     def layer_name(self, val):
-        if isinstance(val, str) and val in list(self._core_stackup.layers.keys()):
-            lay = self._core_stackup.layers["TOP"]._edb_layer
-            if lay:
-                self.primitive_object.SetLayer(lay)
+        layer_list = list(self._core_stackup.layers.keys())
+        if isinstance(val, str) and val in layer_list:
+            layer = self._core_stackup.layers[val]._edb_layer
+            if layer:
+                self.primitive_object.SetLayer(layer)
             else:
-                raise AttributeError("Layer {} not found in layer".format(val))
-        elif isinstance(val, type(self._core_stackup.layers["TOP"])):
+                raise AttributeError("Layer {} not found.".format(val))
+        elif isinstance(val, type(self._core_stackup.layers[layer_list[0]])):
             try:
                 self.primitive_object.SetLayer(val._edb_layer)
             except:
@@ -1301,7 +1302,7 @@ class EDBArcs(object):
 
         Examples
         --------
-        >>> appedb = Edb(fpath, edbversion="2023.2")
+        >>> appedb = Edb(fpath, edbversion="2024.1")
         >>> start_coordinate = appedb.nets["V1P0_S0"].primitives[0].arcs[0].start
         >>> print(start_coordinate)
         [x_value, y_value]
@@ -1320,7 +1321,7 @@ class EDBArcs(object):
 
         Examples
         --------
-        >>> appedb = Edb(fpath, edbversion="2023.2")
+        >>> appedb = Edb(fpath, edbversion="2024.1")
         >>> end_coordinate = appedb.nets["V1P0_S0"].primitives[0].arcs[0].end
         """
         point = self.arc_object.End
@@ -1338,7 +1339,7 @@ class EDBArcs(object):
 
         Examples
         --------
-        >>> appedb = Edb(fpath, edbversion="2023.2")
+        >>> appedb = Edb(fpath, edbversion="2024.1")
         >>> arc_height = appedb.nets["V1P0_S0"].primitives[0].arcs[0].height
         """
         return self.arc_object.Height

pyedb/dotnet/edb_core/edb_data/siwave_simulation_setup_data.py

@@ -22,11 +22,11 @@
 
 import warnings
 
-from pyedb.dotnet.edb_core.edb_data.simulation_setup import BaseSimulationSetup
 from pyedb.dotnet.edb_core.general import (
     convert_netdict_to_pydict,
     convert_pydict_to_netdict,
 )
+from pyedb.dotnet.edb_core.utilities.simulation_setup import BaseSimulationSetup
 from pyedb.generic.general_methods import is_linux, pyedb_function_handler
 
 

pyedb/dotnet/edb_core/edb_data/sources.py

@@ -20,6 +20,8 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+import warnings
+
 from pyedb.generic.constants import NodeType, SourceType
 from pyedb.generic.general_methods import generate_unique_name, pyedb_function_handler
 
@@ -274,9 +276,17 @@ class PinGroup(object):
     def component(self, value):
         self._component = value
 
+    @property
+    def pins(self):
+        """Gets the pins belong to this pin group."""
+        from pyedb.dotnet.edb_core.edb_data.padstacks_data import EDBPadstackInstance
+
+        return {i.GetName(): EDBPadstackInstance(i, self._pedb) for i in list(self._edb_object.GetPins())}
+
     @property
     def node_pins(self):
         """Node pins."""
+        warnings.warn("`node_pins` is deprecated. Use `pins` method instead.", DeprecationWarning)
         return self._node_pins
 
     @node_pins.setter

pyedb/dotnet/edb_core/hfss.py

@@ -1165,7 +1165,7 @@ class EdbHfss(object):
                                     if not ref_prim:
                                         self._logger.error("Failed to collect valid reference primitives for terminal")
                                 if ref_prim:
-                                    reference_layer = ref_prim[0].layer
+                                    reference_layer = ref_prim[0].layer._edb_layer
                                     if term.SetReferenceLayer(reference_layer):  # pragma no cover
                                         self._logger.info("Port {} created".format(port_name))
             return terminal_info

pyedb/dotnet/edb_core/layout.py

@@ -240,6 +240,65 @@ class EdbLayout(object):
                     objinst.append(el)
         return objinst
 
+    @pyedb_function_handler()
+    def get_primitive_by_layer_and_point(self, point=None, layer=None, nets=None):
+        """Return primitive given coordinate point [x, y], layer name and nets.
+
+        Parameters
+        ----------
+        point : list
+            Coordinate [x, y]
+
+        layer : list or str, optional
+            list of layer name or layer name applied on filter.
+
+        nets : list or str, optional
+            list of net name or single net name applied on filter
+
+        Returns
+        -------
+        list of :class:`pyedb.dotnet.edb_core.edb_data.primitives_data.EDBPrimitives`
+            List of primitives, polygons, paths and rectangles.
+        """
+        if isinstance(layer, str) and layer not in list(self._pedb.stackup.signal_layers.keys()):
+            layer = None
+        if not isinstance(point, list) and len(point) == 2:
+            self._logger.error("Provided point must be a list of two values")
+            return False
+        pt = self._edb.geometry.point_data(point[0], point[1])
+        if isinstance(nets, str):
+            nets = [nets]
+        elif nets and not isinstance(nets, list) and len(nets) == len([net for net in nets if isinstance(net, str)]):
+            _nets = []
+            for net in nets:
+                if net not in self._pedb.nets:
+                    self._logger.error(
+                        f"Net {net} used to find primitive from layer point and net not found, skipping it."
+                    )
+                else:
+                    _nets.append(self._pedb.nets[net].net_obj)
+            if _nets:
+                nets = _nets
+        _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()
+                obj_id = prim.GetId()
+                prim_type = str(prim.GetPrimitiveType())
+                if prim_type == "Polygon":
+                    [returned_obj.append(p) for p in [poly for poly in self.polygons if poly.id == obj_id]]
+                elif prim_type == "Path":
+                    [returned_obj.append(p) for p in [t for t in self.paths if t.id == obj_id]]
+                elif prim_type == "Rectangle":
+                    [returned_obj.append(p) for p in [t for t in self.rectangles if t.id == obj_id]]
+        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]]
+        return returned_obj
+
     @pyedb_function_handler()
     def get_polygon_bounding_box(self, polygon):
         """Retrieve a polygon bounding box.
@@ -1126,7 +1185,7 @@ class EdbLayout(object):
         return True
 
     @pyedb_function_handler()
-    def unite_polygons_on_layer(self, layer_name=None, delete_padstack_gemometries=False, net_list=[]):
+    def unite_polygons_on_layer(self, layer_name=None, delete_padstack_gemometries=False, net_names_list=[]):
         """Try to unite all Polygons on specified layer.
 
         Parameters
@@ -1135,8 +1194,8 @@ class EdbLayout(object):
             Name of layer name to unite objects on. The default is ``None``, in which case all layers are taken.
         delete_padstack_gemometries : bool, optional
             Whether to delete all padstack geometries. The default is ``False``.
-        net_list : list[str] : optional
-            Net list filter. The default is ``[]``, in which case all nets are taken.
+        net_names_list : list[str] : optional
+            Net names list filter. The default is ``[]``, in which case all nets are taken.
 
         Returns
         -------
@@ -1151,6 +1210,9 @@ class EdbLayout(object):
         for lay in layer_name:
             self._logger.info("Uniting Objects on layer %s.", lay)
             poly_by_nets = {}
+            all_voids = []
+            list_polygon_data = []
+            delete_list = []
             if lay in list(self.polygons_by_layer.keys()):
                 for poly in self.polygons_by_layer[lay]:
                     if not poly.GetNet().GetName() in list(poly_by_nets.keys()):
@@ -1160,34 +1222,35 @@ class EdbLayout(object):
                         if poly.GetNet().GetName():
                             poly_by_nets[poly.GetNet().GetName()].append(poly)
             for net in poly_by_nets:
-                if net in net_list or not net_list:  # pragma no cover
-                    list_polygon_data = [i.GetPolygonData() for i in poly_by_nets[net]]
-                    all_voids = [i.Voids for i in poly_by_nets[net]]
-                    a = self._edb.geometry.polygon_data.unite(convert_py_list_to_net_list(list_polygon_data))
-                    for item in a:
-                        for v in all_voids:
-                            for void in v:
-                                if int(item.GetIntersectionType(void.GetPolygonData())) == 2:
-                                    item.AddHole(void.GetPolygonData())
-                        poly = self._edb.cell.primitive.polygon.create(
-                            self._active_layout,
-                            lay,
-                            self._pedb.nets.nets[net],
-                            item,
-                        )
-                    list_to_delete = [i for i in poly_by_nets[net]]
-                    for v in all_voids:
-                        for void in v:
-                            for poly in poly_by_nets[net]:  # pragma no cover
-                                if int(void.GetPolygonData().GetIntersectionType(poly.GetPolygonData())) >= 2:
-                                    try:
-                                        id = list_to_delete.index(poly)
-                                    except ValueError:
-                                        id = -1
-                                    if id >= 0:
-                                        list_to_delete.pop(id)
-
-                    [i.Delete() for i in list_to_delete]  # pragma no cover
+                if net in net_names_list or not net_names_list:
+                    for i in poly_by_nets[net]:
+                        list_polygon_data.append(i.GetPolygonData())
+                        delete_list.append(i)
+                        all_voids.append(i.Voids)
+            a = self._edb.geometry.polygon_data.unite(convert_py_list_to_net_list(list_polygon_data))
+            for item in a:
+                for v in all_voids:
+                    for void in v:
+                        if int(item.GetIntersectionType(void.GetPolygonData())) == 2:
+                            item.AddHole(void.GetPolygonData())
+                poly = self._edb.cell.primitive.polygon.create(
+                    self._active_layout,
+                    lay,
+                    self._pedb.nets.nets[net],
+                    item,
+                )
+            for v in all_voids:
+                for void in v:
+                    for poly in poly_by_nets[net]:  # pragma no cover
+                        if int(void.GetPolygonData().GetIntersectionType(poly.GetPolygonData())) >= 2:
+                            try:
+                                id = delete_list.index(poly)
+                            except ValueError:
+                                id = -1
+                            if id >= 0:
+                                delete_list.pop(id)
+            for poly in delete_list:
+                poly.Delete()
 
         if delete_padstack_gemometries:
             self._logger.info("Deleting Padstack Definitions")