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

pyedb/dotnet/edb_core/dotnet/primitive.py

@@ -72,10 +72,38 @@ class PrimitiveDotNet:
         self.edb_api = api._edb
         self.prim_obj = prim_object
 
+    @property
+    def id(self):
+        return self.prim_obj.GetId()
+
     @property
     def api_class(self):
         return self.api
 
+    @property
+    def aedt_name(self):
+        """Name to be visualized in AEDT.
+
+        Returns
+        -------
+        str
+            Name.
+        """
+        from System import String
+
+        val = String("")
+
+        _, name = self.prim_obj.GetProductProperty(self._app._edb.ProductId.Designer, 1, val)
+        name = str(name).strip("'")
+        if name == "":
+            name = "{}__{}".format(self.primitive_type, self.id)
+            self.prim_obj.SetProductProperty(self._app._edb.ProductId.Designer, 1, name)
+        return name
+
+    @aedt_name.setter
+    def aedt_name(self, value):
+        self.prim_obj.SetProductProperty(self._app._edb.ProductId.Designer, 1, value)
+
     @property
     def api_object(self):
         return self.prim_obj
@@ -298,9 +326,9 @@ class PrimitiveDotNet:
                 # i += 1
             else:
                 arc_h = point.GetArcHeight().ToDouble()
-                p1 = [my_net_points[i-1].X.ToDouble(), my_net_points[i-1].Y.ToDouble()]
-                if i+1 < len(my_net_points):
-                    p2 = [my_net_points[i+1].X.ToDouble(), my_net_points[i+1].Y.ToDouble()]
+                p1 = [my_net_points[i - 1].X.ToDouble(), my_net_points[i - 1].Y.ToDouble()]
+                if i + 1 < len(my_net_points):
+                    p2 = [my_net_points[i + 1].X.ToDouble(), my_net_points[i + 1].Y.ToDouble()]
                 else:
                     p2 = [my_net_points[0].X.ToDouble(), my_net_points[0].Y.ToDouble()]
                 x_arc, y_arc = self._eval_arc_points(p1, p2, arc_h, num)
@@ -352,6 +380,61 @@ class PrimitiveDotNet:
         except:
             return points
 
+    def expand(self, offset=0.001, tolerance=1e-12, round_corners=True, maximum_corner_extension=0.001):
+        """Expand the polygon shape by an absolute value in all direction.
+        Offset can be negative for negative expansion.
+
+        Parameters
+        ----------
+        offset : float, optional
+            Offset value in meters.
+        tolerance : float, optional
+            Tolerance in meters.
+        round_corners : bool, optional
+            Whether to round corners or not.
+            If True, use rounded corners in the expansion otherwise use straight edges (can be degenerate).
+        maximum_corner_extension : float, optional
+            The maximum corner extension (when round corners are not used) at which point the corner is clipped.
+        """
+        new_poly = self.polygon_data.edb_api.Expand(offset, tolerance, round_corners, maximum_corner_extension)
+        self.polygon_data = new_poly[0]
+        return True
+
+    def scale(self, factor, center=None):
+        """Scales the polygon relative to a center point by a factor.
+
+        Parameters
+        ----------
+        factor : float
+            Scaling factor.
+        center : List of float or str [x,y], optional
+            If None scaling is done from polygon center.
+
+        Returns
+        -------
+        bool
+           ``True`` when successful, ``False`` when failed.
+        """
+        if not isinstance(factor, str):
+            factor = float(factor)
+            polygon_data = self.polygon_data.create_from_arcs(self.polygon_data.edb_api.GetArcData(), True)
+            if not center:
+                center = self.polygon_data.edb_api.GetBoundingCircleCenter()
+                if center:
+                    polygon_data.Scale(factor, center)
+                    self.polygon_data = polygon_data
+                    return True
+                else:
+                    self._pedb.logger.error(f"Failed to evaluate center on primitive {self.id}")
+            elif isinstance(center, list) and len(center) == 2:
+                center = self._edb.Geometry.PointData(
+                    self._edb.Utility.Value(center[0]), self._edb.Utility.Value(center[1])
+                )
+                polygon_data.Scale(factor, center)
+                self.polygon_data = polygon_data
+                return True
+        return False
+
 
 class RectangleDotNet(PrimitiveDotNet):
     """Class representing a rectangle object."""
@@ -577,6 +660,28 @@ class CircleDotNet(PrimitiveDotNet):
         """:obj:`bool`: If a circle can be a zone."""
         return True
 
+    def expand(self, offset=0.001, tolerance=1e-12, round_corners=True, maximum_corner_extension=0.001):
+        """Expand the polygon shape by an absolute value in all direction.
+        Offset can be negative for negative expansion.
+
+        Parameters
+        ----------
+        offset : float, optional
+            Offset value in meters.
+        tolerance : float, optional
+            Tolerance in meters. Ignored for Circle and Path.
+        round_corners : bool, optional
+            Whether to round corners or not.
+            If True, use rounded corners in the expansion otherwise use straight edges (can be degenerate).
+             Ignored for Circle and Path.
+        maximum_corner_extension : float, optional
+            The maximum corner extension (when round corners are not used) at which point the corner is clipped.
+             Ignored for Circle and Path.
+        """
+        center_x, center_y, radius = self.get_parameters()
+        self.set_parameters(center_x, center_y, radius.ToFloat() + offset)
+        return True
+
 
 class TextDotNet(PrimitiveDotNet):
     """Class representing a text object."""
@@ -851,6 +956,27 @@ class PathDotNet(PrimitiveDotNet):
         """
         return True
 
+    def expand(self, offset=0.001, tolerance=1e-12, round_corners=True, maximum_corner_extension=0.001):
+        """Expand the polygon shape by an absolute value in all direction.
+        Offset can be negative for negative expansion.
+
+        Parameters
+        ----------
+        offset : float, optional
+            Offset value in meters.
+        tolerance : float, optional
+            Tolerance in meters. Ignored for Circle and Path.
+        round_corners : bool, optional
+            Whether to round corners or not.
+            If True, use rounded corners in the expansion otherwise use straight edges (can be degenerate).
+             Ignored for Circle and Path.
+        maximum_corner_extension : float, optional
+            The maximum corner extension (when round corners are not used) at which point the corner is clipped.
+             Ignored for Circle and Path.
+        """
+        self.width = self.width + offset
+        return True
+
 
 class BondwireDotNet(PrimitiveDotNet):
     """Class representing a bondwire object."""

pyedb/dotnet/edb_core/edb_data/hfss_pi_simulation_setup_data.py

@@ -1,460 +0,0 @@
-# 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,
-# FITNE SS 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.general import convert_py_list_to_net_list
-from pyedb.dotnet.edb_core.sim_setup_data.data.sweep_data import SweepData
-from pyedb.dotnet.edb_core.utilities.simulation_setup import SimulationSetup
-from pyedb.generic.general_methods import generate_unique_name
-
-
-class HFSSPISimulationSetup(SimulationSetup):
-    """Manages EDB methods for HFSSPI simulation setup."""
-
-    def __init__(self, pedb, edb_object=None):
-        super().__init__(pedb, edb_object)
-        self._pedb = pedb
-        self._setup_type = "kHFSSPI"
-        self._edb_setup_info = None
-        self.logger = self._pedb.logger
-
-    def create(self, name=None):
-        """Create an HFSS setup."""
-        self._name = name
-        self._create(name)
-        return self
-
-    @property
-    def setup_type(self):
-        return self._setup_type
-
-    @property
-    def settings(self):
-        return HFSSPISimulationSettings(self._edb_setup_info, self._pedb)
-
-    @property
-    def enabled(self):
-        return self.settings.enabled
-
-    @enabled.setter
-    def enabled(self, value):
-        if isinstance(value, bool):
-            self.settings.enabled = value
-        else:
-            self.logger.error(f"Property enabled expects a boolean value while the provided value is {value}.")
-
-    @property
-    def position(self):
-        return self._edb_setup_info.Position
-
-    @position.setter
-    def position(self, value):
-        if isinstance(value, int):
-            self._edb_setup_info.Position = value
-        else:
-            self.logger.error(f"Property position expects an integer value while the provided value is {value}.")
-
-    def add_frequency_sweep(self, name=None, frequency_sweep=None):
-        """Add frequency sweep.
-
-        Parameters
-        ----------
-        name : str, optional
-            Name of the frequency sweep.
-        frequency_sweep : list, optional
-            List of frequency points.
-
-        Returns
-        -------
-        :class:`pyedb.dotnet.edb_core.edb_data.hfss_simulation_setup_data.EdbFrequencySweep`wheen succeeded, ``False``
-        when failed.
-
-        Examples
-        --------
-        >>> setup1 = edbapp.create_hfss_setup("setup1")
-        >>> setup1.add_frequency_sweep(frequency_sweep=[
-        ...                           ["linear count", "0", "1kHz", 1],
-        ...                           ["log scale", "1kHz", "0.1GHz", 10],
-        ...                           ["linear scale", "0.1GHz", "10GHz", "0.1GHz"],
-        ...                           ])
-        """
-        if name in self.frequency_sweeps:
-            self.logger.error("Frequency sweep with same name already defined.")
-            return False
-        if not name:
-            name = generate_unique_name("sweep")
-        return SweepData(self, frequency_sweep, name)
-
-
-class HFSSPISimulationSettings(object):
-    def __init__(self, edb_setup_info, pedb):
-        self._pedb = pedb
-        self.logger = self._pedb.logger
-        self._edb_setup_info = edb_setup_info
-        self._simulation_settings = edb_setup_info.SimulationSettings
-
-    @property
-    def auto_select_nets_for_simulation(self):
-        """Auto select nets for simulation.
-
-        Returns
-        -------
-            bool
-        """
-        return self._simulation_settings.AutoSelectNetsForSimulation
-
-    @auto_select_nets_for_simulation.setter
-    def auto_select_nets_for_simulation(self, value):
-        if isinstance(value, bool):
-            self._simulation_settings.AutoSelectNetsForSimulation = value
-        else:
-            self.logger.error(
-                "Property auto_select_nets_for_simulation expects a boolean "
-                f"value while the provided value is {value}."
-            )
-
-    @property
-    def enabled(self):
-        return self._simulation_settings.Enabled
-
-    @enabled.setter
-    def enabled(self, value):
-        if isinstance(value, bool):
-            self._simulation_settings.Enabled = value
-        else:
-            self.logger.error(f"Property enabled expects a boolean value while the provided value is {value}.")
-
-    @property
-    def ignore_dummy_nets_for_selected_nets(self):
-        """Auto select Nets for simulation
-
-        Returns
-        -------
-            bool
-        """
-        return self._simulation_settings.IgnoreDummyNetsForSelectedNets
-
-    @ignore_dummy_nets_for_selected_nets.setter
-    def ignore_dummy_nets_for_selected_nets(self, value):
-        if isinstance(value, bool):
-            self._simulation_settings.IgnoreDummyNetsForSelectedNets = value
-        else:
-            self.logger.error(
-                "Property ignore_dummy_nets_for_selected_nets expects a boolean "
-                f"value while the provided value is {value}."
-            )
-
-    @property
-    def ignore_small_holes(self):
-        """Ignore small holes choice.
-
-        Returns
-        -------
-            bool
-        """
-        return self._simulation_settings.IgnoreSmallHoles
-
-    @ignore_small_holes.setter
-    def ignore_small_holes(self, value):
-        if isinstance(value, bool):
-            self._simulation_settings.IgnoreSmallHoles = value
-        else:
-            self.logger.error(
-                f"Property ignore_small_holes expects a boolean value while the provided value is {value}."
-            )
-
-    @property
-    def ignore_small_holes_min_diameter(self):
-        """Min diameter to ignore small holes.
-
-        Returns
-        -------
-            str
-        """
-        return self._simulation_settings.IgnoreSmallHolesMinDiameter
-
-    @ignore_small_holes_min_diameter.setter
-    def ignore_small_holes_min_diameter(self, value):
-        self._simulation_settings.IgnoreSmallHolesMinDiameter = self._pedb.edb_value(value).ToString()
-
-    @property
-    def improved_loss_model(self):
-        """Improved Loss Model on power ground nets option.
-
-        Returns
-        -------
-            str
-            ``Level1``, ``Level2``, ``Level3``
-        """
-        return self._simulation_settings.ImprovedLossModel
-
-    @improved_loss_model.setter
-    def improved_loss_model(self, value):
-        expected_values = ["Level1", "Level2", "Level3"]
-        if isinstance(value, str) and value in expected_values:
-            self._simulation_settings.ImprovedLossModel = value
-        else:
-            self.logger.error(
-                "Property improved_loss_model expects a string value among "
-                f"'Level1', 'Level2' or 'Level3' while the provided value is {value}."
-            )
-
-    @property
-    def include_enhanced_bond_wire_modeling(self):
-        """Enhance Bond wire modeling.
-
-        Returns
-        -------
-            bool
-        """
-        return self._simulation_settings.IncludeEnhancedBondWireModeling
-
-    @include_enhanced_bond_wire_modeling.setter
-    def include_enhanced_bond_wire_modeling(self, value):
-        if isinstance(value, bool):
-            self._simulation_settings.IncludeEnhancedBondWireModeling = value
-        else:
-            self.logger.error(
-                "Property include_enhanced_bond_wire_modeling expects a "
-                f"boolean value while the provided value is {value}."
-            )
-
-    @property
-    def include_nets(self):
-        """Add Additional Nets for simulation.
-
-        Returns
-        -------
-            [str]
-            List of net name.
-        """
-        return list(self._simulation_settings.IncludeNets)
-
-    @include_nets.setter
-    def include_nets(self, value):
-        if isinstance(value, str):
-            value = [value]
-        if isinstance(value, list):
-            self._simulation_settings.IncludeNets = convert_py_list_to_net_list(value)
-        else:
-            self.logger.error(
-                f"Property include_nets expects a string or list of string while the provided value is {value}."
-            )
-
-    @property
-    def min_plane_area_to_mesh(self):
-        """The minimum area below which geometry is ignored.
-
-        Returns
-        -------
-            str
-        """
-        return self._simulation_settings.MinPlaneAreaToMesh
-
-    @min_plane_area_to_mesh.setter
-    def min_plane_area_to_mesh(self, value):
-        self._simulation_settings.MinPlaneAreaToMesh = self._pedb.edb_value(value).ToString()
-
-    @property
-    def min_void_area_to_mesh(self):
-        """The minimum area below which voids are ignored.
-
-        Returns
-        -------
-            str
-        """
-        return self._simulation_settings.MinVoidAreaToMesh
-
-    @min_void_area_to_mesh.setter
-    def min_void_area_to_mesh(self, value):
-        self._simulation_settings.MinVoidAreaToMesh = self._pedb.edb_value(value).ToString()
-
-    @property
-    def model_type(self):
-        """Model Type setting.
-
-        Returns
-        -------
-            int
-        Model type: ``0``=RDL, ``1``=Package, ``2``=PCB
-        """
-        return self._simulation_settings.ModelType
-
-    @model_type.setter
-    def model_type(self, value):
-        if isinstance(value, int) and value in range(3):
-            self._simulation_settings.ModelType = value
-        else:
-            self.logger.error(
-                f"Property model_type expects an integer value among 0, 1 or 2 while the provided value is {value}."
-            )
-
-    @property
-    def perform_erc(self):
-        """Perform ERC
-
-        Returns
-        -------
-            bool
-        """
-        return self._simulation_settings.PerformERC
-
-    @perform_erc.setter
-    def perform_erc(self, value):
-        if isinstance(value, bool):
-            self._simulation_settings.PerformERC = value
-        else:
-            self.logger.error(f"Property perform_erc expects a boolean value while the provided value is {value}.")
-
-    @property
-    def pi_slider_pos(self):
-        """The Simulation Preference Slider setting
-
-        Returns
-        -------
-            int
-        Model type: ``0``= balanced, ``1``=Accuracy.
-        """
-        return self._simulation_settings.PISliderPos
-
-    @pi_slider_pos.setter
-    def pi_slider_pos(self, value):
-        if isinstance(value, int) and value in range(2):
-            self._simulation_settings.PISliderPos = value
-        else:
-            self.logger.error(
-                f"Property pi_slider_pos expects an integer value among 0 or 1 while the provided value is {value}."
-            )
-
-    @property
-    def rms_surface_roughness(self):
-        """RMS Surface Roughness setting
-
-        Returns
-        -------
-            str
-        """
-        return self._simulation_settings.RMSSurfaceRoughness
-
-    @rms_surface_roughness.setter
-    def rms_surface_roughness(self, value):
-        self._simulation_settings.RMSSurfaceRoughness = self._pedb.edb_value(value).ToString()
-
-    @property
-    def signal_nets_conductor_modeling(self):
-        """Conductor Modeling
-
-        Returns
-        -------
-            str
-        Value: ``"MeshInside"`` or ``"ImpedanceBoundary"``.
-        """
-        return self._simulation_settings.SignalNetsConductorModeling
-
-    @signal_nets_conductor_modeling.setter
-    def signal_nets_conductor_modeling(self, value):
-        expected_values = ["MeshInside", "ImpedanceBoundary"]
-        if isinstance(value, str) and value in expected_values:
-            self._simulation_settings.SignalNetsConductorModeling = value
-        else:
-            self.logger.error(
-                "Property signal_nets_conductor_modeling expects a string value among "
-                f"'MeshInside' or 'ImpedanceBoundary' while the provided value is {value}."
-            )
-
-    @property
-    def signal_nets_error_tolerance(self):
-        """Error Tolerance
-
-        Returns
-        -------
-            str
-        Value between 0.02 and 1.
-        """
-        return self._simulation_settings.SignalNetsErrorTolerance
-
-    @signal_nets_error_tolerance.setter
-    def signal_nets_error_tolerance(self, value):
-        self._simulation_settings.SignalNetsErrorTolerance = self._pedb.edb_value(value).ToString()
-
-    @property
-    def signal_nets_include_improved_dielectric_fill_refinement(self):
-        return self._simulation_settings.SignalNetsIncludeImprovedDielectricFillRefinement
-
-    @signal_nets_include_improved_dielectric_fill_refinement.setter
-    def signal_nets_include_improved_dielectric_fill_refinement(self, value):
-        if isinstance(value, bool):
-            self._simulation_settings.SignalNetsIncludeImprovedDielectricFillRefinement = value
-        else:
-            self.logger.error(
-                "Property signal_nets_include_improved_dielectric_fill_refinement "
-                f"expects a boolean value while the provided value is {value}."
-            )
-
-    @property
-    def signal_nets_include_improved_loss_handling(self):
-        """Improved Dielectric Fill Refinement choice.
-
-        Returns
-        -------
-            bool
-        """
-        return self._simulation_settings.SignalNetsIncludeImprovedLossHandling
-
-    @signal_nets_include_improved_loss_handling.setter
-    def signal_nets_include_improved_loss_handling(self, value):
-        if isinstance(value, bool):
-            self._simulation_settings.SignalNetsIncludeImprovedLossHandling = value
-        else:
-            self.logger.error(
-                "Property signal_nets_include_improved_loss_handling "
-                f"expects a boolean value while the provided value is {value}."
-            )
-
-    @property
-    def snap_length_threshold(self):
-        return self._simulation_settings.SnapLengthThreshold
-
-    @snap_length_threshold.setter
-    def snap_length_threshold(self, value):
-        self._simulation_settings.SnapLengthThreshold = self._pedb.edb_value(value).ToString()
-
-    @property
-    def surface_roughness_model(self):
-        """Chosen Model setting
-
-        Returns
-        -------
-            str
-        Model allowed, ``"None"``, ``"Exponential"`` or ``"Hammerstad"``.
-        """
-        return self._simulation_settings.SurfaceRoughnessModel
-
-    @surface_roughness_model.setter
-    def surface_roughness_model(self, value):
-        expected_values = ["None", "Exponential", "Hammerstad"]
-        if isinstance(value, str) and value in expected_values:
-            self._simulation_settings.SurfaceRoughnessModel = value
-        else:
-            self.logger.error(
-                "Property surface_roughness_model expects a string value among "
-                f"'None', 'Exponential' or 'Hammerstad' while the provided value is {value}."
-            )