pyedb 0.35.0__tar.gz → 0.37.0__tar.gz

{pyedb-0.35.0 → pyedb-0.37.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyedb
-Version: 0.35.0
+Version: 0.37.0
 Summary: Higher-Level Pythonic Ansys Electronics Data Base
 Author-email: "ANSYS, Inc." <pyansys.core@ansys.com>
 Maintainer-email: PyEDB developers <simon.vandenbrouck@ansys.com>

{pyedb-0.35.0 → pyedb-0.37.0}/src/pyedb/__init__.py

@@ -44,7 +44,7 @@ deprecation_warning()
 #
 
 pyedb_path = os.path.dirname(__file__)
-__version__ = "0.35.0"
+__version__ = "0.37.0"
 version = __version__
 
 #

{pyedb-0.35.0 → pyedb-0.37.0}/src/pyedb/configuration/cfg_ports_sources.py

@@ -33,6 +33,9 @@ class CfgTerminalInfo(CfgBase):
         self._pedb = pedb
         self.type = list(kwargs.keys())[0]
         self.value = kwargs[self.type]
+        self.contact_radius = kwargs.get("contact_radius", None)
+        self.num_of_contact = kwargs.get("num_of_contact", 1)
+        self.inline = kwargs.get("inline", False)
 
     def export_properties(self):
         return {self.type: self.value}
@@ -244,6 +247,7 @@ class CfgCircuitElement(CfgBase):
             point = [self.positive_terminal_info.point_x, self.positive_terminal_info.point_y]
             net_name = self.positive_terminal_info.net
             pos_coor_terminal[self.name] = self._pedb.get_point_terminal(self.name, net_name, point, layer)
+
         elif pos_type == "pin_group":
             if self.distributed:
                 pins = self._get_pins(pos_type, pos_value)
@@ -276,7 +280,7 @@ class CfgCircuitElement(CfgBase):
 
             if neg_type == "coordinates":
                 layer = self.negative_terminal_info.layer
-                point = [self.negative_terminal_info.point_x, self.positive_terminal_info.point_y]
+                point = [self.negative_terminal_info.point_x, self.negative_terminal_info.point_y]
                 net_name = self.negative_terminal_info.net
                 self.neg_terminal = self._pedb.get_point_terminal(self.name + "_ref", net_name, point, layer)
             elif neg_type == "nearest_pin":
@@ -378,6 +382,7 @@ class CfgSource(CfgCircuitElement):
         super().__init__(pedb, **kwargs)
 
         self.magnitude = kwargs.get("magnitude", 0.001)
+        self.equipotential = kwargs.get("equipotential", False)
 
     def set_parameters_to_edb(self):
         """Create sources."""
@@ -397,6 +402,37 @@ class CfgSource(CfgCircuitElement):
                 elem.name = f"{self.name}_{elem.name}"
                 elem.magnitude = self.magnitude / self._elem_num
             circuit_elements.append(elem)
+        for terminal in circuit_elements:
+            if self.equipotential:
+                terms = [terminal, terminal.ref_terminal] if terminal.ref_terminal else [terminal]
+                for t in terms:
+                    if not t.is_reference_terminal:
+                        radius = self.positive_terminal_info.contact_radius
+                        num_of_contact = self.positive_terminal_info.num_of_contact
+                        inline = self.positive_terminal_info.inline
+                    else:
+                        radius = self.negative_terminal_info.contact_radius
+                        num_of_contact = self.negative_terminal_info.num_of_contact
+                        inline = self.negative_terminal_info.inline
+
+                    pads = []
+                    if t.terminal_type == "PadstackInstanceTerminal":
+                        pads.append(t.reference_object)
+                    elif t.terminal_type == "PinGroupTerminal":
+                        name = t._edb_object.GetPinGroup().GetName()
+                        pg = self._pedb.siwave.pin_groups[name]
+                        pads.extend([i for _, i in pg.pins.items()])
+                    elif t.terminal_type == "PointTerminal" and radius:
+                        temp = [i for i in self._pedb.layout.terminals if i.name == t.name][0]
+                        if radius is not None:
+                            prim = self._pedb.modeler.create_circle(
+                                temp.layer.name, temp.location[0], temp.location[1], radius, temp.net_name
+                            )
+                            prim.dcir_equipotential_region = True
+
+                    for i in pads:
+                        i._set_equipotential(contact_radius=radius, inline=inline, num_of_contact=num_of_contact)
+
         return circuit_elements
 
     def export_properties(self):

{pyedb-0.35.0 → pyedb-0.37.0}/src/pyedb/dotnet/edb.py

@@ -603,7 +603,7 @@ class Edb(Database):
     def import_layout_pcb(
         self,
         input_file,
-        working_dir,
+        working_dir="",
         anstranslator_full_path="",
         use_ppe=False,
         control_file=None,
@@ -616,7 +616,7 @@ class Edb(Database):
         ----------
         input_file : str
             Full path to the board file.
-        working_dir : str
+        working_dir : str, optional
             Directory in which to create the ``aedb`` folder. The name given to the AEDB file
             is the same as the name of the board file.
         anstranslator_full_path : str, optional
@@ -1510,6 +1510,13 @@ class Edb(Database):
             else:
                 return False
         else:
+            if anstranslator_full_path and os.path.exists(anstranslator_full_path):
+                path = anstranslator_full_path
+            else:
+                path = os.path.join(self.base_path, "anstranslator")
+                if is_windows:
+                    path += ".exe"
+
             temp_map_file = os.path.splitext(inputGDS)[0] + ".map"
             temp_layermap_file = os.path.splitext(inputGDS)[0] + ".layermap"
 
@@ -1529,10 +1536,10 @@ class Edb(Database):
                     else:
                         self.logger.error("Unable to define control file.")
 
-                command = [anstranslator_full_path, inputGDS, f'-g="{map_file}"', f'-c="{control_file}"']
+                command = [path, inputGDS, f'-g="{map_file}"', f'-c="{control_file}"']
             else:
                 command = [
-                    anstranslator_full_path,
+                    path,
                     inputGDS,
                     f'-o="{control_file_temp}"' f'-t="{tech_file}"',
                     f'-g="{map_file}"',

{pyedb-0.35.0 → pyedb-0.37.0}/src/pyedb/dotnet/edb_core/cell/layout.py

@@ -220,7 +220,7 @@ class Layout(ObjBase):
         -------
         """
 
-        return [EDBNetsData(net, self._pedb) for net in self._edb_object.Nets]
+        return [EDBNetsData(net, self._pedb) for net in self._edb_object.Nets if net]
 
     @property
     def primitives(self):
@@ -230,7 +230,7 @@ class Layout(ObjBase):
         -------
         list of :class:`dotnet.edb_core.dotnet.primitive.PrimitiveDotNet` cast objects.
         """
-        return [primitive_cast(self._pedb, p) for p in self._edb_object.Primitives]
+        return [primitive_cast(self._pedb, p) for p in self._edb_object.Primitives if p]
 
     @property
     def bondwires(self):
@@ -331,16 +331,32 @@ class Layout(ObjBase):
         obj = self._pedb._edb.Cell.Hierarchy.Component.FindByName(self._edb_object, value)
         return EDBComponent(self._pedb, obj) if obj is not None else None
 
-    def find_primitive(self, layer_name: Union[str, list]) -> list:
+    def find_primitive(
+        self, layer_name: Union[str, list] = None, name: Union[str, list] = None, net_name: Union[str, list] = None
+    ) -> list:
         """Find a primitive objects by layer name.
 
         Parameters
         ----------
-        layer_name : str, list
+        layer_name : str, list, optional
             Name of the layer.
+        name : str, list, optional
+            Name of the primitive
+        net_name : str, list, optional
+            Name of the primitive
         Returns
         -------
         list
         """
-        layer_name = layer_name if isinstance(layer_name, list) else [layer_name]
-        return [i for i in self.primitives if i.layer_name in layer_name]
+        if layer_name is not None:
+            layer_name = layer_name if isinstance(layer_name, list) else [layer_name]
+        if name is not None:
+            name = name if isinstance(name, list) else [name]
+        if net_name is not None:
+            net_name = net_name if isinstance(net_name, list) else [net_name]
+
+        prims = self.primitives
+        prims = [i for i in prims if i.aedt_name in name] if name is not None else prims
+        prims = [i for i in prims if i.layer_name in layer_name] if layer_name is not None else prims
+        prims = [i for i in prims if i.net_name in net_name] if net_name is not None else prims
+        return prims

{pyedb-0.35.0 → pyedb-0.37.0}/src/pyedb/dotnet/edb_core/cell/primitive/primitive.py

@@ -19,6 +19,7 @@
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
+import re
 
 from pyedb.dotnet.edb_core.cell.connectable import Connectable
 from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
@@ -787,3 +788,66 @@ class Primitive(Connectable):
                 self.polygon_data = polygon_data
                 return True
         return False
+
+    @property
+    def _em_properties(self):
+        """Get EM properties."""
+        default = (
+            r"$begin 'EM properties'\n"
+            r"\tType('Mesh')\n"
+            r"\tDataId='EM properties1'\n"
+            r"\t$begin 'Properties'\n"
+            r"\t\tGeneral=''\n"
+            r"\t\tModeled='true'\n"
+            r"\t\tUnion='true'\n"
+            r"\t\t'Use Precedence'='false'\n"
+            r"\t\t'Precedence Value'='1'\n"
+            r"\t\tPlanarEM=''\n"
+            r"\t\tRefined='true'\n"
+            r"\t\tRefineFactor='1'\n"
+            r"\t\tNoEdgeMesh='false'\n"
+            r"\t\tHFSS=''\n"
+            r"\t\t'Solve Inside'='false'\n"
+            r"\t\tSIwave=''\n"
+            r"\t\t'DCIR Equipotential Region'='false'\n"
+            r"\t$end 'Properties'\n"
+            r"$end 'EM properties'\n"
+        )
+
+        pid = self._pedb.edb_api.ProductId.Designer
+        _, p = self._edb_object.GetProductProperty(pid, 18, "")
+        if p:
+            return p
+        else:
+            return default
+
+    @_em_properties.setter
+    def _em_properties(self, em_prop):
+        """Set EM properties"""
+        pid = self._pedb.edb_api.ProductId.Designer
+        self._edb_object.SetProductProperty(pid, 18, em_prop)
+
+    @property
+    def dcir_equipotential_region(self):
+        """Check whether dcir equipotential region is enabled.
+
+        Returns
+        -------
+        bool
+        """
+        pattern = r"'DCIR Equipotential Region'='([^']+)'"
+        em_pp = self._em_properties
+        result = re.search(pattern, em_pp).group(1)
+        if result == "true":
+            return True
+        else:
+            return False
+
+    @dcir_equipotential_region.setter
+    def dcir_equipotential_region(self, value):
+        """Set dcir equipotential region."""
+        pp = r"'DCIR Equipotential Region'='true'" if value else r"'DCIR Equipotential Region'='false'"
+        em_pp = self._em_properties
+        pattern = r"'DCIR Equipotential Region'='([^']+)'"
+        new_em_pp = re.sub(pattern, pp, em_pp)
+        self._em_properties = new_em_pp

{pyedb-0.35.0 → pyedb-0.37.0}/src/pyedb/dotnet/edb_core/edb_data/control_file.py

@@ -25,6 +25,7 @@ import os
 import re
 import subprocess
 import sys
+import xml
 
 from pyedb.edb_logger import pyedb_logger
 from pyedb.generic.general_methods import ET, env_path, env_value, is_linux
@@ -964,14 +965,14 @@ class ControlFileMeshOp:
 class ControlFileSetup:
     """Setup Class."""
 
-    def __init__(self, name):
+    def __init__(self, name, adapt_freq="1GHz", maxdelta=0.02, maxpasses=10):
         self.name = name
         self.enabled = True
         self.save_fields = False
         self.save_rad_fields = False
-        self.frequency = "1GHz"
-        self.maxpasses = 10
-        self.max_delta = 0.02
+        self.frequency = adapt_freq
+        self.maxpasses = maxpasses
+        self.max_delta = maxdelta
         self.union_polygons = True
         self.small_voids_area = 0
         self.mode_type = "IC"
@@ -1082,22 +1083,25 @@ class ControlFileSetups:
     def __init__(self):
         self.setups = []
 
-    def add_setup(self, name, frequency):
+    def add_setup(self, name, adapt_freq, maxdelta, maxpasses):
         """Add a new setup
 
         Parameters
         ----------
         name : str
-            Setup name.
-        frequency : str
+            Setup Name.
+        adapt_freq : str, optional
             Setup Frequency.
+        maxdelta : float, optional
+            Maximum Delta.
+        maxpasses : int, optional
+            Maximum Number of Passes.
 
         Returns
         -------
         :class:`pyedb.dotnet.edb_core.edb_data.control_file.ControlFileSetup`
         """
-        setup = ControlFileSetup(name)
-        setup.frequency = frequency
+        setup = ControlFileSetup(name, adapt_freq, maxdelta, maxpasses)
         self.setups.append(setup)
         return setup
 
@@ -1112,17 +1116,17 @@ class ControlFile:
 
     def __init__(self, xml_input=None, tecnhology=None, layer_map=None):
         self.stackup = ControlFileStackup()
+        self.boundaries = ControlFileBoundaries()
+        self.setups = ControlFileSetups()
         if xml_input:
             self.parse_xml(xml_input)
         if tecnhology:
             self.parse_technology(tecnhology)
         if layer_map:
             self.parse_layer_map(layer_map)
-        self.boundaries = ControlFileBoundaries()
         self.remove_holes = False
         self.remove_holes_area_minimum = 30
         self.remove_holes_units = "um"
-        self.setups = ControlFileSetups()
         self.components = ControlFileComponents()
         self.import_options = ControlFileImportOptions()
         pass
@@ -1262,6 +1266,50 @@ class ControlFile:
                                                 via.remove_unconnected = (
                                                     True if i.attrib["RemoveUnconnected"] == "true" else False
                                                 )
+            if el.tag == "Boundaries":
+                for port_el in el:
+                    if port_el.tag == "CircuitPortPt":
+                        self.boundaries.add_port(
+                            name=port_el.attrib["Name"],
+                            x1=port_el.attrib["x1"],
+                            y1=port_el.attrib["y1"],
+                            layer1=port_el.attrib["Layer1"],
+                            x2=port_el.attrib["x2"],
+                            y2=port_el.attrib["y2"],
+                            layer2=port_el.attrib["Layer2"],
+                            z0=port_el.attrib["Z0"],
+                        )
+            setups = root.find("SimulationSetups")
+            if setups:
+                hfsssetup = setups.find("HFSSSetup")
+                if hfsssetup:
+                    if "Name" in hfsssetup.attrib:
+                        name = hfsssetup.attrib["Name"]
+                    hfsssimset = hfsssetup.find("HFSSSimulationSettings")
+                    if hfsssimset:
+                        hfssadaptset = hfsssimset.find("HFSSAdaptiveSettings")
+                        if hfssadaptset:
+                            adaptset = hfssadaptset.find("AdaptiveSettings")
+                            if adaptset:
+                                singlefreqdatalist = adaptset.find("SingleFrequencyDataList")
+                                if singlefreqdatalist:
+                                    adaptfreqdata = singlefreqdatalist.find("AdaptiveFrequencyData")
+                                    if adaptfreqdata:
+                                        if isinstance(
+                                            adaptfreqdata.find("AdaptiveFrequency"), xml.etree.ElementTree.Element
+                                        ):
+                                            adapt_freq = adaptfreqdata.find("AdaptiveFrequency").text
+                                        else:
+                                            adapt_freq = "1GHz"
+                                        if isinstance(adaptfreqdata.find("MaxDelta"), xml.etree.ElementTree.Element):
+                                            maxdelta = adaptfreqdata.find("MaxDelta").text
+                                        else:
+                                            maxdelta = 0.02
+                                        if isinstance(adaptfreqdata.find("MaxPasses"), xml.etree.ElementTree.Element):
+                                            maxpasses = adaptfreqdata.find("MaxPasses").text
+                                        else:
+                                            maxpasses = 10
+                self.setups.add_setup(name, adapt_freq, maxdelta, maxpasses)
         return True
 
     def write_xml(self, xml_output):
@@ -1278,8 +1326,7 @@ class ControlFile:
         """
         control = ET.Element("{http://www.ansys.com/control}Control", attrib={"schemaVersion": "1.0"})
         self.stackup._write_xml(control)
-        if self.boundaries.ports or self.boundaries.extents:
-            self.boundaries._write_xml(control)
+        self.boundaries._write_xml(control)
         if self.remove_holes:
             hole = ET.SubElement(control, "RemoveHoles")
             hole.set("HoleAreaMinimum", str(self.remove_holes_area_minimum))

{pyedb-0.35.0 → pyedb-0.37.0}/src/pyedb/dotnet/edb_core/edb_data/nets_data.py

@@ -59,7 +59,7 @@ class EDBNetsData(NetDotNet):
         """
         from pyedb.dotnet.edb_core.cell.layout import primitive_cast
 
-        return [primitive_cast(self._app, i) for i in self.net_object.Primitives]
+        return [primitive_cast(self._app, i) for i in self.net_object.Primitives if i]
         # return [self._app.layout.find_object_by_id(i.GetId()) for i in self.net_object.Primitives]
 
     @property

{pyedb-0.35.0 → pyedb-0.37.0}/src/pyedb/dotnet/edb_core/edb_data/padstacks_data.py

@@ -22,9 +22,10 @@
 
 from collections import OrderedDict
 import math
-import re
 import warnings
 
+import numpy as np
+
 from pyedb.dotnet.clr_module import String
 from pyedb.dotnet.edb_core.cell.primitive.primitive import Primitive
 from pyedb.dotnet.edb_core.dotnet.database import PolygonDataDotNet
@@ -1248,68 +1249,77 @@ class EDBPadstackInstance(Primitive):
 
         return self._pedb.create_port(terminal, ref_terminal, is_circuit_port)
 
-    @property
-    def _em_properties(self):
-        """Get EM properties."""
-        default = (
-            r"$begin 'EM properties'\n"
-            r"\tType('Mesh')\n"
-            r"\tDataId='EM properties1'\n"
-            r"\t$begin 'Properties'\n"
-            r"\t\tGeneral=''\n"
-            r"\t\tModeled='true'\n"
-            r"\t\tUnion='true'\n"
-            r"\t\t'Use Precedence'='false'\n"
-            r"\t\t'Precedence Value'='1'\n"
-            r"\t\tPlanarEM=''\n"
-            r"\t\tRefined='true'\n"
-            r"\t\tRefineFactor='1'\n"
-            r"\t\tNoEdgeMesh='false'\n"
-            r"\t\tHFSS=''\n"
-            r"\t\t'Solve Inside'='false'\n"
-            r"\t\tSIwave=''\n"
-            r"\t\t'DCIR Equipotential Region'='false'\n"
-            r"\t$end 'Properties'\n"
-            r"$end 'EM properties'\n"
-        )
-
-        pid = self._pedb.edb_api.ProductId.Designer
-        _, p = self._edb_padstackinstance.GetProductProperty(pid, 18, "")
-        if p:
-            return p
-        else:
-            return default
+    def _set_equipotential(self, contact_radius=None, inline=False, num_of_contact=1):
+        """Workaround solution. Remove when EDBAPI bug is fixed for dcir_equipotential_region."""
+        pad = self.definition.pad_by_layer[self.start_layer]
 
-    @_em_properties.setter
-    def _em_properties(self, em_prop):
-        """Set EM properties"""
-        pid = self._pedb.edb_api.ProductId.Designer
-        self._edb_padstackinstance.SetProductProperty(pid, 18, em_prop)
+        pos_x, pos_y = self.position
+        comp_rotation = self._pedb.edb_value(self.component.rotation).ToDouble() % 3.141592653589793
 
-    @property
-    def dcir_equipotential_region(self):
-        """Check whether dcir equipotential region is enabled.
+        if contact_radius is not None:
+            if num_of_contact == 1:
+                prim = self._pedb.modeler.create_circle(pad.layer_name, pos_x, pos_y, contact_radius, self.net_name)
+                prim.dcir_equipotential_region = True
+            else:
+                if pad.shape.lower() in ["rectangle", "oval"]:
+                    width, height = pad.parameters_values[0:2]
+                    radius = self._pedb.edb_value(contact_radius).ToDouble()
+                else:
+                    return
+
+                if inline is False:
+                    x_offset = width / 2 - radius if comp_rotation == 0 else height / 2 - radius
+                    y_offset = height / 2 - radius if comp_rotation == 0 else width / 2 - radius
+                    positions = []
+                    for x, y in [[1, 1], [-1, 1], [1, -1], [-1, -1]]:
+                        positions.append([x_offset * x, y_offset * y])
+                else:
+                    if width > height:
+                        offset = (width - radius * 2) / (num_of_contact - 1)
+                    else:
+                        offset = (height - radius * 2) / (num_of_contact - 1)
+
+                    start_pos = (num_of_contact - 1) / 2
+                    offset = [offset * i for i in np.arange(start_pos * -1, start_pos + 1)]
+
+                    if (width > height and comp_rotation == 0) or (width < height and comp_rotation != 0):
+                        positions = list(zip(offset, [0] * num_of_contact))
+                    else:
+                        positions = list(zip([0] * num_of_contact, offset))
+
+                for x, y in positions:
+                    prim = self._pedb.modeler.create_circle(pad.layer_name, pos_x + x, pos_y + y, radius, self.net_name)
+                    prim.dcir_equipotential_region = True
+            return
 
-        Returns
-        -------
-        bool
-        """
-        pattern = r"'DCIR Equipotential Region'='([^']+)'"
-        em_pp = self._em_properties
-        result = re.search(pattern, em_pp).group(1)
-        if result == "true":
-            return True
+        elif pad.shape.lower() == "circle":
+            ra = self._pedb.edb_value(pad.parameters_values[0] / 2)
+            pos = self.position
+            prim = self._pedb.modeler.create_circle(pad.layer_name, pos[0], pos[1], ra, self.net_name)
+        elif pad.shape.lower() == "rectangle":
+            width, height = pad.parameters_values
+            prim = self._pedb.modeler.create_rectangle(
+                pad.layer_name,
+                self.net_name,
+                width=width,
+                height=height,
+                representation_type="CenterWidthHeight",
+                center_point=self.position,
+                rotation=self.component.rotation,
+            )
+        elif pad.shape.lower() == "oval":
+            width, height, _ = pad.parameters_values
+            prim = self._pedb.modeler.create_circle(
+                pad.layer_name, self.position[0], self.position[1], height / 2, self.net_name
+            )
+        elif pad.polygon_data:
+            prim = self._pedb.modeler.create_polygon(
+                pad.polygon_data._edb_object, self.start_layer, net_name=self.net_name
+            )
+            prim.move(self.position)
         else:
-            return False
-
-    @dcir_equipotential_region.setter
-    def dcir_equipotential_region(self, value):
-        """Set dcir equipotential region."""
-        pp = r"'DCIR Equipotential Region'='true'" if value else r"'DCIR Equipotential Region'='false'"
-        em_pp = self._em_properties
-        pattern = r"'DCIR Equipotential Region'='([^']+)'"
-        new_em_pp = re.sub(pattern, pp, em_pp)
-        self._em_properties = new_em_pp
+            return
+        prim.dcir_equipotential_region = True
 
     @property
     def object_instance(self):
@@ -1577,7 +1587,6 @@ class EDBPadstackInstance(Primitive):
         str
             Name of the starting layer.
         """
-        layer = self._pedb.edb_api.cell.layer("", self._pedb.edb_api.cell.layer_type.SignalLayer)
         _, start_layer, stop_layer = self._edb_object.GetLayerRange()
 
         if start_layer:
@@ -1599,7 +1608,6 @@ class EDBPadstackInstance(Primitive):
         str
             Name of the stopping layer.
         """
-        layer = self._pedb.edb_api.cell.layer("", self._pedb.edb_api.cell.layer_type.SignalLayer)
         _, start_layer, stop_layer = self._edb_padstackinstance.GetLayerRange()
 
         if stop_layer:
@@ -1620,7 +1628,7 @@ class EDBPadstackInstance(Primitive):
         layer_list = []
         start_layer_name = start_layer.GetName()
         stop_layer_name = stop_layer.GetName()
-        for layer_name in list(self._pedb.stackup.layers.keys()):
+        for layer_name in list(self._pedb.stackup.signal_layers.keys()):
             if started:
                 layer_list.append(layer_name)
                 if layer_name == stop_layer_name or layer_name == start_layer_name:
@@ -1705,7 +1713,6 @@ class EDBPadstackInstance(Primitive):
         float
             Rotatation value for the padstack instance.
         """
-        point_data = self._pedb.edb_api.geometry.point_data(self._pedb.edb_value(0.0), self._pedb.edb_value(0.0))
         out = self._edb_padstackinstance.GetPositionAndRotationValue()
 
         if out[0]:

{pyedb-0.35.0 → pyedb-0.37.0}/src/pyedb/dotnet/edb_core/geometry/polygon_data.py

@@ -19,6 +19,7 @@
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
+from typing import Union
 
 from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
 from pyedb.dotnet.edb_core.geometry.point_data import PointData
@@ -128,3 +129,7 @@ class PolygonData:
             arcs = convert_py_list_to_net_list(arcs)
         poly = self._edb_object.CreateFromArcs(arcs, flag)
         return PolygonData(self._pedb, poly)
+
+    def point_in_polygon(self, x: Union[str, float], y: Union[str, float]) -> bool:
+        """Determines whether a point is inside the polygon."""
+        return self._edb_object.PointInPolygon(self._pedb.point_data(x, y))

{pyedb-0.35.0 → pyedb-0.37.0}/src/pyedb/dotnet/edb_core/modeler.py

@@ -661,8 +661,7 @@ class Modeler(object):
         else:
             polygonData = main_shape
         if not polygonData or polygonData.IsNull():
-            self._logger.error("Failed to create main shape polygon data")
-            return False
+            raise RuntimeError("Failed to create main shape polygon data")
         for void in voids:
             if isinstance(void, list):
                 void = self.Shape("polygon", points=void)