pyedb 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

pyedb/dotnet/edb_core/definition/package_def.py

@@ -20,8 +20,8 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-from pyedb.dotnet.edb_core.dotnet.database import PolygonDataDotNet
-from pyedb.dotnet.edb_core.edb_data.obj_base import ObjBase
+from pyedb.dotnet.edb_core.geometry.polygon_data import PolygonData
+from pyedb.dotnet.edb_core.obj_base import ObjBase
 from pyedb.generic.general_methods import pyedb_function_handler
 
 
@@ -33,19 +33,24 @@ class PackageDef(ObjBase):
     pedb : :class:`pyedb.edb`
         Edb object.
     edb_object : object
-        Edb PackageDef Object
+    Edb PackageDef Object
+        component_part_name : str, optional
+        Part name of the component.
+    extent_bounding_box : list, optional
+        Bounding box defines the shape of the package. For example, [[0, 0], ["2mm", "2mm"].
+
     """
 
-    def __init__(self, pedb, edb_object=None, name=None):
-        self._pedb = pedb
-        if edb_object is None and name is not None:
-            self._edb_object = self.__create_from_name(name)
+    def __init__(self, pedb, edb_object=None, name=None, component_part_name=None, extent_bounding_box=None):
+        super().__init__(pedb, edb_object)
+        if self._edb_object is None and name is not None:
+            self._edb_object = self.__create_from_name(name, component_part_name, extent_bounding_box)
         else:
             self._edb_object = edb_object
 
     @pyedb_function_handler
-    def __create_from_name(self, name):
-        """Create a package defininitiion.
+    def __create_from_name(self, name, component_part_name=None, extent_bounding_box=None):
+        """Create a package definition.
 
         Parameters
         ----------
@@ -58,15 +63,34 @@ class PackageDef(ObjBase):
             EDB PackageDef Object
         """
         edb_object = self._pedb.edb_api.definition.PackageDef.Create(self._pedb.active_db, name)
-        pointA = self._pedb.edb_api.geometry.point_data(
-            self._pedb.edb_value(0),
-            self._pedb.edb_value(0),
-        )
+        if component_part_name:
+            x_pt1, y_pt1, x_pt2, y_pt2 = list(
+                self._pedb.components.definitions[component_part_name].components.values()
+            )[0].bounding_box
+            x_mid = (x_pt1 + x_pt2) / 2
+            y_mid = (y_pt1 + y_pt2) / 2
+            bbox = [[y_pt1 - y_mid, x_pt1 - x_mid], [y_pt2 - y_mid, x_pt2 - x_mid]]
+        else:
+            bbox = extent_bounding_box
+        polygon_data = PolygonData(self._pedb, create_from_bounding_box=True, points=bbox)
 
-        polygon = PolygonDataDotNet(self._pedb).create_from_bbox([pointA, pointA])
-        edb_object.SetExteriorBoundary(polygon)
+        edb_object.SetExteriorBoundary(polygon_data._edb_object)
         return edb_object
 
+    @pyedb_function_handler
+    def delete(self):
+        """Delete a package definition object from the database."""
+        return self._edb_object.Delete()
+
+    @property
+    def exterior_boundary(self):
+        """Get the exterior boundary of a package definition."""
+        return PolygonData(self._pedb, self._edb_object.GetExteriorBoundary()).points
+
+    @exterior_boundary.setter
+    def exterior_boundary(self, value):
+        self._edb_object.SetExteriorBoundary(value._edb_object)
+
     @property
     def maximum_power(self):
         """Maximum power of the package."""
@@ -116,3 +140,25 @@ class PackageDef(ObjBase):
     def height(self, value):
         value = self._pedb.edb_value(value)
         self._edb_object.SetHeight(value)
+
+    @pyedb_function_handler
+    def set_heatsink(self, fin_base_height, fin_height, fin_orientation, fin_spacing, fin_thickness):
+        from pyedb.dotnet.edb_core.utilities.heatsink import HeatSink
+
+        heatsink = HeatSink(self._pedb)
+        heatsink.fin_base_height = fin_base_height
+        heatsink.fin_height = fin_height
+        heatsink.fin_orientation = fin_orientation
+        heatsink.fin_spacing = fin_spacing
+        heatsink.fin_thickness = fin_thickness
+        self._edb_object.SetHeatSink(heatsink._edb_object)
+
+    @property
+    def heatsink(self):
+        from pyedb.dotnet.edb_core.utilities.heatsink import HeatSink
+
+        flag, edb_object = self._edb_object.GetHeatSink()
+        if flag:
+            return HeatSink(self._pedb, edb_object)
+        else:
+            return None

pyedb/dotnet/edb_core/dotnet/database.py

@@ -721,10 +721,11 @@ class EdbDotNet(object):
         """Initialize DLLs."""
         from pyedb.dotnet.clr_module import _clr, edb_initialized
 
-        if settings.enable_screen_logs:
-            self._logger.enable_stdout_log()
-        else:  # pragma: no cover
-            self._logger.disable_stdout_log()
+        if not settings.use_pyaedt_log:
+            if settings.enable_screen_logs:
+                self._logger.enable_stdout_log()
+            else:  # pragma: no cover
+                self._logger.disable_stdout_log()
         if not edb_initialized:  # pragma: no cover
             self._logger.error("Failed to initialize Dlls.")
             return

pyedb/dotnet/edb_core/edb_data/components_data.py

@@ -329,7 +329,7 @@ class EDBComponent(object):
 
     @solder_ball_height.setter
     def solder_ball_height(self, value):
-        if "GetSolderBallProperty" in dir(self.component_property) and value:
+        if "GetSolderBallProperty" in dir(self.component_property):
             sball_height = round(self._edb.utility.Value(value).ToDouble(), 9)
             cmp_property = self.component_property
             solder_ball_prop = cmp_property.GetSolderBallProperty().Clone()
@@ -375,7 +375,7 @@ class EDBComponent(object):
 
     @property
     def solder_ball_diameter(self):
-        """Solder ball diameter"""
+        """Solder ball diameter."""
         if "GetSolderBallProperty" in dir(self.component_property):
             result = self.component_property.GetSolderBallProperty().GetDiameter()
             succeed = result[0]
@@ -850,6 +850,7 @@ class EDBComponent(object):
     @property
     def is_top_mounted(self):
         """Check if a component is mounted on top or bottom of the layout.
+
         Returns
         -------
         bool

pyedb/dotnet/edb_core/edb_data/connectable.py

@@ -20,7 +20,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-from pyedb.dotnet.edb_core.edb_data.obj_base import ObjBase
+from pyedb.dotnet.edb_core.obj_base import ObjBase
 from pyedb.generic.general_methods import pyedb_function_handler
 
 

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,18 @@ 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:
+                    material_name = layer["material"]["name"]
+                    self._pclass._pedb.materials.add_material(material_name, **material_data)
+                    self.material = 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

@@ -688,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
 
@@ -808,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:
@@ -887,7 +888,7 @@ class EdbPath(EDBPrimitives, PathDotNet):
             return self._app.hfss.create_edge_port_vertical(self.id, pos, name, 50, reference_layer)
 
     @pyedb_function_handler()
-    def create_via_fence(self, distance, gap, padstack_name):
+    def create_via_fence(self, distance, gap, padstack_name, net_name="GND"):
         """Create via fences on both sides of the trace.
 
         Parameters
@@ -898,6 +899,8 @@ class EdbPath(EDBPrimitives, PathDotNet):
             Gap between vias.
         padstack_name: str
             Name of the via padstack.
+        net_name: str, optional
+            Name of the net.
 
         Returns
         -------
@@ -989,7 +992,7 @@ class EdbPath(EDBPrimitives, PathDotNet):
         center_line = self.get_center_line()
         leftline, rightline = getParalletLines(center_line, distance)
         for x, y in getLocations(rightline, gap) + getLocations(leftline, gap):
-            self._pedb.padstacks.place([x, y], padstack_name)
+            self._pedb.padstacks.place([x, y], padstack_name, net_name=net_name)
 
 
 class EdbRectangle(EDBPrimitives, RectangleDotNet):
@@ -1301,7 +1304,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 +1323,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 +1341,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,12 @@
 
 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.dotnet.sim_setup_data.data.siw_dc_ir_settings import SiwaveDCIRSettings
 from pyedb.generic.general_methods import is_linux, pyedb_function_handler
 
 
@@ -1144,6 +1145,11 @@ class SiwaveDCSimulationSetup(SiwaveSYZSimulationSetup):
         self.set_dc_slider(1)
         return self
 
+    @property
+    def dc_ir_settings(self):
+        """DC IR settings."""
+        return SiwaveDCIRSettings(self)
+
     @pyedb_function_handler
     def get_configurations(self):
         """Get SIwave DC simulation settings.

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/{edb_data/obj_base.py → geometry/point_data.py}

@@ -21,31 +21,17 @@
 # SOFTWARE.
 
 
-class ObjBase(object):
-    """Manages EDB functionalities for a base object."""
+class PointData:
+    """Point Data."""
 
-    def __init__(self, pedb, edb_object):
+    def __init__(self, pedb, edb_object=None, x=None, y=None):
         self._pedb = pedb
-        self._edb_object = edb_object
-
-    @property
-    def is_null(self):
-        """Flag indicating if this object is null."""
-        return self._edb_object.IsNull()
-
-    @property
-    def type(self):
-        """Type of the edb object."""
-        try:
-            return self._edb_object.GetType()
-        except AttributeError:  # pragma: no cover
-            return None
-
-    @property
-    def name(self):
-        """Name of the definition."""
-        return self._edb_object.GetName()
-
-    @name.setter
-    def name(self, value):
-        self._edb_object.SetName(value)
+        if edb_object:
+            self._edb_object = edb_object
+        else:
+            x = x if x else 0
+            y = y if y else 0
+            self._edb_object = self._pedb.edb_api.geometry.point_data(
+                self._pedb.edb_value(x),
+                self._pedb.edb_value(y),
+            )

pyedb/dotnet/edb_core/geometry/polygon_data.py

@@ -0,0 +1,77 @@
+# 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 pyedb.dotnet.edb_core.geometry.point_data import PointData
+from pyedb.dotnet.edb_core.obj_base import BBox
+from pyedb.generic.general_methods import pyedb_function_handler
+
+
+class PolygonData:
+    """Polygon Data."""
+
+    def __init__(
+        self,
+        pedb,
+        edb_object=None,
+        create_from_points=None,
+        create_from_circle=None,
+        create_from_rectangle=None,
+        create_from_bounding_box=None,
+        **kwargs,
+    ):
+        self._pedb = pedb
+
+        if create_from_points:
+            self._edb_object = self.create_from_points(**kwargs)
+        elif create_from_circle:
+            x_center, y_center, radius = kwargs
+        elif create_from_rectangle:
+            x_lower_left, y_lower_left, x_upper_right, y_upper_right = kwargs
+        elif create_from_bounding_box:
+            self._edb_object = self.create_from_bounding_box(**kwargs)
+        else:  # pragma: no cover
+            self._edb_object = edb_object
+
+    @property
+    def points(self):
+        """Get all points in polygon.
+
+        Returns
+        -------
+        list[list[float]]
+        """
+        return [
+            [self._pedb.edb_value(i.X).ToDouble(), self._pedb.edb_value(i.Y).ToDouble()]
+            for i in list(self._edb_object.Points)
+        ]
+
+    @pyedb_function_handler
+    def create_from_points(self, points, closed=True):
+        list_of_point_data = []
+        for pt in points:
+            list_of_point_data.append(PointData(self._pedb, x=pt[0], y=pt[1]))
+        return self._pedb.edb_api.geometry.api_class.PolygonData(list_of_point_data, closed)
+
+    @pyedb_function_handler
+    def create_from_bounding_box(self, points):
+        bbox = BBox(self._pedb, point_1=points[0], point_2=points[1])
+        return self._pedb.edb_api.geometry.api_class.PolygonData.CreateFromBBox(bbox._edb_object)

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.