pyedb 0.15.dev0__py3-none-any.whl → 0.17.0__py3-none-any.whl

pyedb/dotnet/edb_core/cell/voltage_regulator.py

@@ -0,0 +1,143 @@
+# 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.cell.layout_obj import Connectable
+from pyedb.dotnet.edb_core.edb_data.padstacks_data import EDBPadstackInstance
+
+
+class VoltageRegulator(Connectable):
+    """Class managing EDB voltage regulator."""
+
+    def __init__(self, pedb, edb_object=None):
+        super().__init__(pedb, edb_object)
+
+    @property
+    def component(self):
+        """Retrieve voltage regulator component"""
+        if not self._edb_object.GetComponent().IsNull():
+            ref_des = self._edb_object.GetComponent().GetName()
+            if not ref_des:
+                return False
+            return self._pedb.components.instances[ref_des]
+        self._pedb.logger.warning("No voltage regulator component.")
+        return False
+
+    @component.setter
+    def component(self, value):
+        if not isinstance(value, str):
+            self._pedb.logger.error("refdes name must be provided to set vrm component")
+            return
+        if value not in self._pedb.components.instances:
+            self._pedb.logger.error(f"component {value} not found in layout")
+            return
+        self._edb_object.SetGroup(self._pedb.components.instances[value].edbcomponent)
+
+    @property
+    def load_regulator_current(self):
+        """Retrieve load regulator current value"""
+        return self._edb_object.GetLoadRegulationCurrent().ToDouble()
+
+    @load_regulator_current.setter
+    def load_regulator_current(self, value):
+        _value = self._pedb.edb_value(value)
+        self._edb_object.SetLoadRegulationCurrent(_value)
+
+    @property
+    def load_regulation_percent(self):
+        """Retrieve load regulation percent value."""
+        return self._edb_object.GetLoadRegulationPercent().ToDouble()
+
+    @load_regulation_percent.setter
+    def load_regulation_percent(self, value):
+        _value = self._edb_object.edb_value(value)
+        self._edb_object.SetLoadRegulationPercent(_value)
+
+    @property
+    def name(self):
+        """Retrieve voltage regulator name."""
+        return self._edb_object.GetName()
+
+    @name.setter
+    def name(self, value):
+        if isinstance(value, str):
+            self._edb_object.SetName(value)
+
+    @property
+    def negative_remote_sense_pin(self):
+        """Retrieve negative remote sense pin."""
+        edb_pin = self._edb_object.GetNegRemoteSensePin()
+        return self._pedb.padstacks.instances[edb_pin.GetId()]
+
+    @negative_remote_sense_pin.setter
+    def negative_remote_sense_pin(self, value):
+        if isinstance(value, int):
+            if value in self._pedb.padsatcks.instances:
+                _inst = self._pedb.padsatcks.instances[value]
+                if self._edb_object.SetNegRemoteSensePin(_inst._edb_object):
+                    self._negative_remote_sense_pin = _inst
+        elif isinstance(value, EDBPadstackInstance):
+            if self._edb_object.SetNegRemoteSensePin(value._edb_object):
+                self._negative_remote_sense_pin = value
+
+    @property
+    def positive_remote_sense_pin(self):
+        """Retrieve positive remote sense pin."""
+        edb_pin = self._edb_object.GetPosRemoteSensePin()
+        return self._pedb.padstacks.instances[edb_pin.GetId()]
+
+    @positive_remote_sense_pin.setter
+    def positive_remote_sense_pin(self, value):
+        if isinstance(value, int):
+            if value in self._pedb.padsatcks.instances:
+                _inst = self._pedb.padsatcks.instances[value]
+                if self._edb_object.SetPosRemoteSensePin(_inst._edb_object):
+                    self._positive_remote_sense_pin = _inst
+                if not self.component:
+                    self.component = _inst._edb_object.GetComponent().GetName()
+        elif isinstance(value, EDBPadstackInstance):
+            if self._edb_object.SetPosRemoteSensePin(value._edb_object):
+                self._positive_remote_sense_pin = value
+            if not self.component:
+                self.component = value._edb_object.GetComponent().GetName()
+
+    @property
+    def voltage(self):
+        """Retrieve voltage value."""
+        return self._edb_object.GetVoltage().ToDouble()
+
+    @voltage.setter
+    def voltage(self, value):
+        self._edb_object.SetVoltage(self._pedb.edb_value(value))
+
+    @property
+    def is_active(self):
+        """Check is voltage regulator is active."""
+        return self._edb_object.IsActive()
+
+    @is_active.setter
+    def is_active(self, value):
+        if isinstance(value, bool):
+            self._edb_object.SetIsActive(value)
+
+    @property
+    def is_null(self):
+        return self._edb_object.IsNull()

pyedb/dotnet/edb_core/components.py

@@ -174,7 +174,7 @@ class Components(object):
         Examples
         --------
 
-        >>> from pyedb.dotnet.edb import Edb
+        >>> from pyedb import Edb
         >>> edbapp = Edb("myaedbfolder")
         >>> edbapp.components.components
 
@@ -194,7 +194,7 @@ class Components(object):
         Examples
         --------
 
-        >>> from pyedb.dotnet.edb import Edb
+        >>> from pyedb import Edb
         >>> edbapp = Edb("myaedbfolder")
         >>> edbapp.components.components
 

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."""