pyedb 0.13.dev0__py3-none-any.whl → 0.15.dev0__py3-none-any.whl

pyedb/dotnet/edb_core/padstack.py

@@ -35,7 +35,7 @@ from pyedb.dotnet.edb_core.edb_data.padstacks_data import (
     EDBPadstackInstance,
 )
 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
+from pyedb.generic.general_methods import generate_unique_name
 from pyedb.modeler.geometry_operators import GeometryOperators
 
 
@@ -49,7 +49,6 @@ class EdbPadstacks(object):
     >>> edb_padstacks = edbapp.padstacks
     """
 
-    @pyedb_function_handler()
     def __getitem__(self, name):
         """Get  a padstack definition or instance from the Edb project.
 
@@ -59,7 +58,7 @@ class EdbPadstacks(object):
 
         Returns
         -------
-        :class:`pyedb.dotnet.edb_core.edb_data.components_data.EDBComponent`
+        :class:`pyedb.dotnet.edb_core.cell.hierarchy.component.EDBComponent`
 
         """
         if name in self.instances:
@@ -109,7 +108,6 @@ class EdbPadstacks(object):
         """ """
         return self._pedb.stackup.stackup_layers
 
-    @pyedb_function_handler()
     def int_to_pad_type(self, val=0):
         """Convert an integer to an EDB.PadGeometryType.
 
@@ -136,7 +134,6 @@ class EdbPadstacks(object):
         else:
             return val
 
-    @pyedb_function_handler()
     def int_to_geometry_type(self, val=0):
         """Convert an integer to an EDB.PadGeometryType.
 
@@ -329,7 +326,6 @@ class EdbPadstacks(object):
 
         return PadType
 
-    @pyedb_function_handler()
     def create_circular_padstack(
         self,
         padstackname=None,
@@ -431,7 +427,6 @@ class EdbPadstacks(object):
                 )
         PadStack.SetData(new_PadStackData)
 
-    @pyedb_function_handler()
     def delete_padstack_instances(self, net_names):  # pragma: no cover
         """Delete padstack instances by net names.
 
@@ -459,7 +454,6 @@ class EdbPadstacks(object):
                     return False
         return True
 
-    @pyedb_function_handler()
     def set_solderball(self, padstackInst, sballLayer_name, isTopPlaced=True, ballDiam=100e-6):
         """Set solderball for the given PadstackInstance.
 
@@ -502,7 +496,6 @@ class EdbPadstacks(object):
 
         return False
 
-    @pyedb_function_handler()
     def create_coax_port(self, padstackinstance, use_dot_separator=True, name=None):
         """Create HFSS 3Dlayout coaxial lumped port on a pastack
         Requires to have solder ball defined before calling this method.
@@ -564,11 +557,9 @@ class EdbPadstacks(object):
             return port_name
         return ""
 
-    @pyedb_function_handler()
     def _port_exist(self, port_name):
         return any(port for port in list(self._pedb.excitations.keys()) if port == port_name)
 
-    @pyedb_function_handler()
     def get_pinlist_from_component_and_net(self, refdes=None, netname=None):
         """Retrieve pins given a component's reference designator and net name.
 
@@ -605,7 +596,6 @@ class EdbPadstacks(object):
 
         return pinlist
 
-    @pyedb_function_handler()
     def get_pad_parameters(self, pin, layername, pad_type=0):
         """Get Padstack Parameters from Pin or Padstack Definition.
 
@@ -661,7 +651,6 @@ class EdbPadstacks(object):
                 return geometry_type, parameters, offset_x, offset_y, rotation
             return 0, [0], 0, 0, 0
 
-    @pyedb_function_handler()
     def set_all_antipad_value(self, value):
         """Set all anti-pads from all pad-stack definition to the given value.
 
@@ -710,7 +699,6 @@ class EdbPadstacks(object):
                 padstack.edb_padstack.SetData(cloned_padstack_data)
             return all_succeed
 
-    @pyedb_function_handler()
     def check_and_fix_via_plating(self, minimum_value_to_replace=0.0, default_plating_ratio=0.2):
         """Check for minimum via plating ration value, values found below the minimum one are replaced by default
         plating ratio.
@@ -736,7 +724,6 @@ class EdbPadstacks(object):
                 )
         return True
 
-    @pyedb_function_handler()
     def get_via_instance_from_net(self, net_list=None):
         """Get the list for EDB vias from a net name list.
 
@@ -767,7 +754,6 @@ class EdbPadstacks(object):
                     via_list.append(lobj)
         return via_list
 
-    @pyedb_function_handler()
     def create_padstack(
         self,
         padstackname=None,
@@ -850,7 +836,6 @@ class EdbPadstacks(object):
             pad_rotation=pad_rotation,
         )
 
-    @pyedb_function_handler()
     def create(
         self,
         padstackname=None,
@@ -958,7 +943,7 @@ class EdbPadstacks(object):
                 else:
                     return False
             elif isinstance(polygon_hole, PolygonDataDotNet):
-                hole_param = polygon_hole
+                hole_param = polygon_hole.edb_api
             else:
                 return False
             padstackData.SetPolygonalHoleParameters(hole_param, value0, value0, value0)
@@ -1077,7 +1062,6 @@ class EdbPadstacks(object):
         self._logger.info("Padstack %s create correctly", padstackname)
         return padstackname
 
-    @pyedb_function_handler()
     def _get_pin_layer_range(self, pin):
         res, fromlayer, tolayer = pin.GetLayerRange()
         if res:
@@ -1085,7 +1069,6 @@ class EdbPadstacks(object):
         else:
             return False
 
-    @pyedb_function_handler()
     def duplicate_padstack(self, target_padstack_name, new_padstack_name=""):
         """Duplicate a padstack.
 
@@ -1107,7 +1090,6 @@ class EdbPadstacks(object):
         warnings.warn("Use :func:`create` method instead.", DeprecationWarning)
         return self.duplicate(target_padstack_name=target_padstack_name, new_padstack_name=new_padstack_name)
 
-    @pyedb_function_handler()
     def duplicate(self, target_padstack_name, new_padstack_name=""):
         """Duplicate a padstack.
 
@@ -1134,7 +1116,6 @@ class EdbPadstacks(object):
 
         return new_padstack_name
 
-    @pyedb_function_handler()
     def place(
         self,
         position,
@@ -1221,7 +1202,6 @@ class EdbPadstacks(object):
         else:
             return False
 
-    @pyedb_function_handler()
     def place_padstack(
         self,
         position,
@@ -1276,7 +1256,6 @@ class EdbPadstacks(object):
             is_pin=is_pin,
         )
 
-    @pyedb_function_handler()
     def remove_pads_from_padstack(self, padstack_name, layer_name=None):
         """Remove the Pad from a padstack on a specific layer by setting it as a 0 thickness circle.
 
@@ -1309,7 +1288,6 @@ class EdbPadstacks(object):
         self.definitions[padstack_name].edb_padstack.SetData(newPadstackDefinitionData)
         return True
 
-    @pyedb_function_handler()
     def set_pad_property(
         self,
         padstack_name,
@@ -1411,7 +1389,6 @@ class EdbPadstacks(object):
         self.definitions[padstack_name].edb_padstack.SetData(new_padstack_def)
         return True
 
-    @pyedb_function_handler()
     def get_instances(
         self,
         name=None,
@@ -1467,7 +1444,6 @@ class EdbPadstacks(object):
                     instances = [inst for inst in instances if inst.pin_number in component_pin]
             return instances
 
-    @pyedb_function_handler()
     def get_padstack_instance_by_net_name(self, net_name):
         """Get a list of padstack instances by net name.
 
@@ -1484,7 +1460,6 @@ class EdbPadstacks(object):
         warnings.warn("Use new property :func:`get_padstack_instance` instead.", DeprecationWarning)
         return self.get_instances(net_name=net_name)
 
-    @pyedb_function_handler()
     def get_reference_pins(
         self, positive_pin, reference_net="gnd", search_radius=5e-3, max_limit=0, component_only=True
     ):
@@ -1542,7 +1517,6 @@ class EdbPadstacks(object):
             pinlist = [pin[1] for pin in sorted(pin_dict.items())[:max_limit]]
         return pinlist
 
-    @pyedb_function_handler()
     def get_padstack_instances_rtree_index(self, nets=None):
         """Returns padstack instances Rtree index.
 
@@ -1568,7 +1542,6 @@ class EdbPadstacks(object):
             padstack_instances_index.insert(inst.id, inst.position)
         return padstack_instances_index
 
-    @pyedb_function_handler()
     def get_padstack_instances_intersecting_bounding_box(self, bounding_box, nets=None):
         """Returns the list of padstack instances ID intersecting a given bounding box and nets.
 
@@ -1592,3 +1565,76 @@ class EdbPadstacks(object):
         if isinstance(bounding_box, list):
             bounding_box = tuple(bounding_box)
         return list(index.intersection(bounding_box))
+
+    def merge_via_along_lines(self, net_name="GND", distance_threshold=5e-3, minimum_via_number=6):
+        """Replace padstack instances along lines into a single polygon.
+
+        Detect all padstack instances that are placed along lines and replace them by a single polygon based one
+        forming a wall shape. This method is designed to simplify meshing on via fence usually added to shield RF traces
+        on PCB.
+
+        Parameters
+        ----------
+        net_name : str
+            Net name used for detected padstack instances. Default value is ``"GND"``.
+
+        distance_threshold : float, None, optional
+            If two points in a line are separated by a distance larger than `distance_threshold`,
+            the line is divided in two parts. Default is ``5e-3`` (5mm), in which case the control is not performed.
+
+        minimum_via_number : int, optional
+            The minimum number of points that a line must contain. Default is ``6``.
+
+        Returns
+        -------
+        bool
+            ``True`` when succeeded ``False`` when failed. <
+
+        """
+        _def = list(
+            set([inst.padstack_definition for inst in list(self.instances.values()) if inst.net_name == net_name])
+        )
+        if not _def:
+            self._logger.error(f"No padstack definition found for net {net_name}")
+            return False
+        _instances_to_delete = []
+        padstack_instances = []
+        for pdstk_def in _def:
+            padstack_instances.append(
+                [inst for inst in self.definitions[pdstk_def].instances if inst.net_name == net_name]
+            )
+        for pdstk_series in padstack_instances:
+            instances_location = [inst.position for inst in pdstk_series]
+            lines, line_indexes = GeometryOperators.find_points_along_lines(
+                points=instances_location,
+                minimum_number_of_points=minimum_via_number,
+                distance_threshold=distance_threshold,
+            )
+            for line in line_indexes:
+                [_instances_to_delete.append(pdstk_series[ind]) for ind in line]
+                start_point = pdstk_series[line[0]]
+                stop_point = pdstk_series[line[-1]]
+                padstack_def = start_point.padstack_definition
+                trace_width = self.definitions[padstack_def].pad_by_layer[stop_point.start_layer].parameters_values[0]
+                trace = self._pedb.modeler.create_trace(
+                    path_list=[start_point.position, stop_point.position],
+                    layer_name=start_point.start_layer,
+                    width=trace_width,
+                )
+                polygon_data = trace.polygon_data
+                trace.delete()
+                new_padstack_def = generate_unique_name(padstack_def)
+                if not self.create(
+                    padstackname=new_padstack_def,
+                    pad_shape="Polygon",
+                    antipad_shape="Polygon",
+                    pad_polygon=polygon_data,
+                    antipad_polygon=polygon_data,
+                    polygon_hole=polygon_data,
+                ):
+                    self._logger.error(f"Failed to create padstack definition {new_padstack_def}")
+                if not self.place(position=[0, 0], definition_name=new_padstack_def, net_name=net_name):
+                    self._logger.error(f"Failed to place padstack instance {new_padstack_def}")
+            for inst in _instances_to_delete:
+                inst.delete()
+        return True

pyedb/dotnet/edb_core/sim_setup_data/data/adaptive_frequency_data.py

@@ -0,0 +1,72 @@
+# 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.
+
+
+class AdaptiveFrequencyData(object):
+    """Manages EDB methods for adaptive frequency data."""
+
+    def __init__(self, adaptive_frequency_data):
+        self._adaptive_frequency_data = adaptive_frequency_data
+
+    @property
+    def adaptive_frequency(self):
+        """Adaptive frequency for the setup.
+
+        Returns
+        -------
+        str
+            Frequency with units.
+        """
+        return self._adaptive_frequency_data.AdaptiveFrequency
+
+    @adaptive_frequency.setter
+    def adaptive_frequency(self, value):
+        self._adaptive_frequency_data.AdaptiveFrequency = value
+
+    @property
+    def max_delta(self):
+        """Maximum change of S-parameters between two consecutive passes, which serves as
+        a stopping criterion.
+
+        Returns
+        -------
+        str
+        """
+        return self._adaptive_frequency_data.MaxDelta
+
+    @max_delta.setter
+    def max_delta(self, value):
+        self._adaptive_frequency_data.MaxDelta = str(value)
+
+    @property
+    def max_passes(self):
+        """Maximum allowed number of mesh refinement cycles.
+
+        Returns
+        -------
+        int
+        """
+        return self._adaptive_frequency_data.MaxPasses
+
+    @max_passes.setter
+    def max_passes(self, value):
+        self._adaptive_frequency_data.MaxPasses = value

pyedb/dotnet/edb_core/sim_setup_data/data/mesh_operation.py

@@ -0,0 +1,287 @@
+# 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 System import Tuple
+
+from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
+
+
+class MeshOperation(object):
+    """Mesh Operation Class."""
+
+    def __init__(self, parent, mesh_operation):
+        self._parent = parent
+        self.mesh_operation = mesh_operation
+        self._mesh_op_mapping = {
+            "kMeshSetupBase": mesh_operation.TMeshOpType.kMeshSetupBase,
+            "kMeshSetupLength": mesh_operation.TMeshOpType.kMeshSetupLength,
+            "kMeshSetupSkinDepth": mesh_operation.TMeshOpType.kMeshSetupSkinDepth,
+            "kNumMeshOpTypes": mesh_operation.TMeshOpType.kNumMeshOpTypes,
+        }
+
+    @property
+    def enabled(self):
+        """Whether if mesh operation is enabled.
+
+        Returns
+        -------
+        bool
+            ``True`` if mesh operation is used, ``False`` otherwise.
+        """
+        return self.mesh_operation.Enabled
+
+    @property
+    def mesh_operation_type(self):
+        """Mesh operation type.
+        Options:
+        0- ``kMeshSetupBase``
+        1- ``kMeshSetupLength``
+        2- ``kMeshSetupSkinDepth``
+        3- ``kNumMeshOpTypes``.
+
+        Returns
+        -------
+        int
+        """
+        return self.mesh_operation.MeshOpType.ToString()
+
+    @property
+    def mesh_region(self):
+        """Mesh region name.
+
+        Returns
+        -------
+        str
+            Name of the mesh region.
+        """
+        return self.mesh_operation.MeshRegion
+
+    @property
+    def name(self):
+        """Mesh operation name.
+
+        Returns
+        -------
+        str
+        """
+        return self.mesh_operation.Name
+
+    @property
+    def nets_layers_list(self):
+        """List of nets and layers.
+
+        Returns
+        -------
+        list
+           List of lists with three elements. Each list must contain:
+           1- net name
+           2- layer name
+           3- bool.
+           Third element is represents whether if the mesh operation is enabled or disabled.
+
+        """
+        return self.mesh_operation.NetsLayersList
+
+    @nets_layers_list.setter
+    def nets_layers_list(self, values):
+        temp = []
+        for net, layers in values.items():
+            for layer in layers:
+                temp.append(Tuple[str, str, bool](net, layer, True))
+        self.mesh_operation.NetsLayersList = convert_py_list_to_net_list(temp)
+
+    @property
+    def refine_inside(self):
+        """Whether to turn on refine inside objects.
+
+        Returns
+        -------
+        bool
+            ``True`` if refine inside objects is used, ``False`` otherwise.
+
+        """
+        return self.mesh_operation.RefineInside
+
+    @enabled.setter
+    def enabled(self, value):
+        self.mesh_operation.Enabled = value
+        self._parent._update_setup()
+
+    @mesh_region.setter
+    def mesh_region(self, value):
+        self.mesh_operation.MeshRegion = value
+        self._parent._update_setup()
+
+    @name.setter
+    def name(self, value):
+        self.mesh_operation.Name = value
+        self._parent._update_setup()
+
+    @refine_inside.setter
+    def refine_inside(self, value):
+        self.mesh_operation.RefineInside = value
+        self._parent._update_setup()
+
+    @property
+    def max_elements(self):
+        """Maximum number of elements.
+
+        Returns
+        -------
+        str
+        """
+        return self.mesh_operation.MaxElems
+
+    @property
+    def restrict_max_elements(self):
+        """Whether to restrict maximum number  of elements.
+
+        Returns
+        -------
+        bool
+        """
+        return self.mesh_operation.RestrictMaxElem
+
+    @max_elements.setter
+    def max_elements(self, value):
+        self.mesh_operation.MaxElems = str(value)
+        self._parent._update_setup()
+
+    @restrict_max_elements.setter
+    def restrict_max_elements(self, value):
+        """Whether to restrict maximum number  of elements.
+
+        Returns
+        -------
+        bool
+        """
+        self.mesh_operation.RestrictMaxElem = value
+        self._parent._update_setup()
+
+
+class MeshOperationLength(MeshOperation, object):
+    """Mesh operation Length class.
+    This class is accessible from Hfss Setup in EDB and add_length_mesh_operation method.
+
+    Examples
+    --------
+    >>> mop = edbapp.setups["setup1a"].add_length_mesh_operation({"GND": ["TOP", "BOTTOM"]})
+    >>> mop.max_elements = 3000
+    """
+
+    def __init__(self, parent, mesh_operation):
+        MeshOperation.__init__(self, parent, mesh_operation)
+
+    @property
+    def max_length(self):
+        """Maximum length of elements.
+
+        Returns
+        -------
+        str
+        """
+        return self.mesh_operation.MaxLength
+
+    @property
+    def restrict_length(self):
+        """Whether to restrict length of elements.
+
+        Returns
+        -------
+        bool
+        """
+        return self.mesh_operation.RestrictLength
+
+    @max_length.setter
+    def max_length(self, value):
+        self.mesh_operation.MaxLength = value
+        self._parent._update_setup()
+
+    @restrict_length.setter
+    def restrict_length(self, value):
+        """Whether to restrict length of elements.
+
+        Returns
+        -------
+        bool
+        """
+        self.mesh_operation.RestrictLength = value
+        self._parent._update_setup()
+
+
+class MeshOperationSkinDepth(MeshOperation, object):
+    """Mesh operation Skin Depth class.
+    This class is accessible from Hfss Setup in EDB and assign_skin_depth_mesh_operation method.
+
+    Examples
+    --------
+    >>> mop = edbapp.setups["setup1a"].add_skin_depth_mesh_operation({"GND": ["TOP", "BOTTOM"]})
+    >>> mop.max_elements = 3000
+    """
+
+    def __init__(self, parent, mesh_operation):
+        MeshOperation.__init__(self, parent, mesh_operation)
+
+    @property
+    def skin_depth(self):
+        """Skin depth value.
+
+        Returns
+        -------
+        str
+        """
+        return self.mesh_operation.SkinDepth
+
+    @skin_depth.setter
+    def skin_depth(self, value):
+        self.mesh_operation.SkinDepth = value
+        self._parent._update_setup()
+
+    @property
+    def surface_triangle_length(self):
+        """Surface triangle length value.
+
+        Returns
+        -------
+        str
+        """
+        return self.mesh_operation.SurfTriLength
+
+    @surface_triangle_length.setter
+    def surface_triangle_length(self, value):
+        self.mesh_operation.SurfTriLength = value
+        self._parent._update_setup()
+
+    @property
+    def number_of_layer_elements(self):
+        """Number of layer elements.
+
+        Returns
+        -------
+        str
+        """
+        return self.mesh_operation.NumLayers
+
+    @number_of_layer_elements.setter
+    def number_of_layer_elements(self, value):
+        self.mesh_operation.NumLayers = str(value)
+        self._parent._update_setup()