pyedb 0.52.0__py3-none-any.whl → 0.54.0__py3-none-any.whl

pyedb/dotnet/database/utilities/siwave_simulation_setup.py

@@ -280,6 +280,21 @@ class SiwaveSimulationSetup(SimulationSetup):
         """List of frequency sweeps."""
         return {i.name: i for i in self._siwave_sweeps_list}
 
+    @property
+    def dc_settings(self):
+        """SIwave DC setting."""
+        return DCSettings(self)
+
+    @property
+    def dc_advanced_settings(self):
+        """Siwave DC advanced settings.
+
+        Returns
+        -------
+        :class:`pyedb.dotnet.database.edb_data.siwave_simulation_setup_data.SiwaveDCAdvancedSettings`
+        """
+        return DCAdvancedSettings(self)
+
 
 class SiwaveDCSimulationSetup(SimulationSetup):
     """Manages EDB methods for SIwave DC simulation setup."""

pyedb/dotnet/database/utilities/value.py

@@ -0,0 +1,116 @@
+# 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 Value(float):
+    """Class defining Edb Value properties."""
+
+    def __new__(cls, pedb, edb_obj):
+        temp = super().__new__(cls, float(round(edb_obj.ToDouble(), 9)))
+        temp._pedb = pedb
+        temp._edb_obj = edb_obj
+        return temp
+
+    def __str__(self):
+        """Returns the string of the variable.
+
+        Returns
+        -------
+        str
+        """
+        return self._edb_obj.ToString()
+
+    def __add__(self, other):
+        """Adds two Edb Values."""
+        edb_object = self._pedb.core.utility.value(f"({self._edb_obj.ToString()})+({str(other)})")
+        return self.__class__(self._pedb, edb_object)
+
+    def __radd__(self, other):
+        edb_object = self._pedb.core.utility.value(f"({str(other)})+({self._edb_obj.ToString()})")
+        return self.__class__(self._pedb, edb_object)
+
+    def __sub__(self, other):
+        """Subtracts two Edb Values."""
+        edb_object = self._pedb.core.utility.value(f"({self._edb_obj.ToString()})-({str(other)})")
+        return self.__class__(self._pedb, edb_object)
+
+    def __rsub__(self, other):
+        edb_object = self._pedb.core.utility.value(f"({str(other)})-({self._edb_obj.ToString()})")
+        return self.__class__(self._pedb, edb_object)
+
+    def __mul__(self, other):
+        """Multiplies two Edb Values."""
+        edb_object = self._pedb.core.utility.value(f"({self._edb_obj.ToString()})*({str(other)})")
+        return self.__class__(self._pedb, edb_object)
+
+    def __rmul__(self, other):
+        edb_object = self._pedb.core.utility.value(f"({str(other)})*({self._edb_obj.ToString()})")
+        return self.__class__(self._pedb, edb_object)
+
+    def __truediv__(self, other):
+        """Divides two Edb Values."""
+        edb_object = self._pedb.core.utility.value(f"({self._edb_obj.ToString()})/({str(other)})")
+        return self.__class__(self._pedb, edb_object)
+
+    def __rtruediv__(self, other):
+        edb_object = self._pedb.core.utility.value(f"({str(other)})/({self._edb_obj.ToString()})")
+        return self.__class__(self._pedb, edb_object)
+
+    def sqrt(self):
+        """Square root of the value."""
+        edb_object = self._pedb.core.utility.value(f"({self._edb_obj.ToString()})**0.5")
+        return self.__class__(self._pedb, edb_object)
+
+    def log10(self):
+        """Base-10 logarithm of the value."""
+        edb_object = self._pedb.core.utility.value(f"log10({self._edb_obj.ToString()})")
+        return self.__class__(self._pedb, edb_object)
+
+    def sin(self):
+        """Sine of the value."""
+        edb_object = self._pedb.core.utility.value(f"sin({self._edb_obj.ToString()})")
+        return self.__class__(self._pedb, edb_object)
+
+    def cos(self):
+        """Cosine of the value."""
+        edb_object = self._pedb.core.utility.value(f"cos({self._edb_obj.ToString()})")
+        return self.__class__(self._pedb, edb_object)
+
+    def asin(self):
+        """Arcsine of the value."""
+        edb_object = self._pedb.core.utility.value(f"asin({self._edb_obj.ToString()})")
+        return self.__class__(self._pedb, edb_object)
+
+    def acos(self):
+        """Arccosine of the value."""
+        edb_object = self._pedb.core.utility.value(f"acos({self._edb_obj.ToString()})")
+        return self.__class__(self._pedb, edb_object)
+
+    def tan(self):
+        """Tangent of the value."""
+        edb_object = self._pedb.core.utility.value(f"tan({self._edb_obj.ToString()})")
+        return self.__class__(self._pedb, edb_object)
+
+    def atan(self):
+        """Arctangent of the value."""
+        edb_object = self._pedb.core.utility.value(f"atan({self._edb_obj.ToString()})")
+        return self.__class__(self._pedb, edb_object)

pyedb/dotnet/edb.py

@@ -92,6 +92,7 @@ from pyedb.dotnet.database.utilities.siwave_simulation_setup import (
     SiwaveDCSimulationSetup,
     SiwaveSimulationSetup,
 )
+from pyedb.dotnet.database.utilities.value import Value
 from pyedb.edb_logger import pyedb_logger
 from pyedb.generic.constants import AEDT_UNITS, SolverType, unit_converter
 from pyedb.generic.general_methods import (
@@ -104,6 +105,7 @@ from pyedb.generic.process import SiwaveSolve
 from pyedb.generic.settings import settings
 from pyedb.ipc2581.ipc2581 import Ipc2581
 from pyedb.modeler.geometry_operators import GeometryOperators
+from pyedb.siwave_core.product_properties import SIwaveProperties
 from pyedb.workflow import Workflow
 
 
@@ -397,8 +399,14 @@ class Edb(Database):
 
     @property
     def pedb_class(self):
-        if not self.grpc:
-            return pyedb.dotnet
+        return pyedb.dotnet
+
+    def value(self, val):
+        """Convert a value into a pyedb value."""
+        if isinstance(val, self._edb.Utility.Value):
+            return Value(self, val)
+        else:
+            return Value(self, self.core.utility.value(val))
 
     @property
     def grpc(self):
@@ -620,9 +628,7 @@ class Edb(Database):
             return None
         if not self.cellname:
             self.cellname = generate_unique_name("Cell")
-        self._active_cell = self.edb_api.cell.create(
-            self.active_db, self.edb_api.cell.CellType.CircuitCell, self.cellname
-        )
+        self._active_cell = self.core.cell.create(self.active_db, self.core.cell.CellType.CircuitCell, self.cellname)
         if self._active_cell:
             self._init_objects()
             return True
@@ -1366,7 +1372,7 @@ class Edb(Database):
         Instance of `Edb.Utility.Value`
 
         """
-        return self.edb_api.utility.value(val)
+        return self.core.utility.value(val)
 
     def point_3d(self, x, y, z=0.0):
         """Compute the Edb 3d Point Data.
@@ -1384,7 +1390,7 @@ class Edb(Database):
         -------
         ``Geometry.Point3DData``.
         """
-        return self.edb_api.geometry.point3d_data(x, y, z)
+        return self.core.geometry.point3d_data(x, y, z)
 
     def point_data(self, x, y=None):
         """Compute the Edb Point Data.
@@ -1402,9 +1408,9 @@ class Edb(Database):
         ``Geometry.PointData``.
         """
         if y is None:
-            return self.edb_api.geometry.point_data(x)
+            return self.core.geometry.point_data(x)
         else:
-            return self.edb_api.geometry.point_data(x, y)
+            return self.core.geometry.point_data(x, y)
 
     def _is_file_existing_and_released(self, filename):
         if os.path.exists(filename):
@@ -1468,7 +1474,7 @@ class Edb(Database):
         warnings.warn("Use new property :func:`close` instead.", DeprecationWarning)
         return self.close()
 
-    def close(self):
+    def close(self, **kwargs):
         """Close EDB and cleanup variables.
 
         Returns
@@ -1589,7 +1595,7 @@ class Edb(Database):
             ``True`` when successful, ``False`` when failed.
 
         """
-        return self.edb_api.utility.utility.Command.Execute(func)
+        return self.core.utility.utility.Command.Execute(func)
 
     def import_cadence_file(self, inputBrd, WorkDir=None, anstranslator_full_path="", use_ppe=False):
         """Import a board file and generate an ``edb.def`` file in the working directory.
@@ -1638,7 +1644,7 @@ class Edb(Database):
     ):
         if extent_type in [
             "Conforming",
-            self.edb_api.geometry.extent_type.Conforming,
+            self.core.geometry.extent_type.Conforming,
             1,
         ]:
             if use_pyaedt_extent:
@@ -1656,7 +1662,7 @@ class Edb(Database):
             else:
                 _poly = self.layout.expanded_extent(
                     net_signals,
-                    self.edb_api.geometry.extent_type.Conforming,
+                    self.core.geometry.extent_type.Conforming,
                     expansion_size,
                     False,
                     use_round_corner,
@@ -1664,12 +1670,12 @@ class Edb(Database):
                 )
         elif extent_type in [
             "Bounding",
-            self.edb_api.geometry.extent_type.BoundingBox,
+            self.core.geometry.extent_type.BoundingBox,
             0,
         ]:
             _poly = self.layout.expanded_extent(
                 net_signals,
-                self.edb_api.geometry.extent_type.BoundingBox,
+                self.core.geometry.extent_type.BoundingBox,
                 expansion_size,
                 False,
                 use_round_corner,
@@ -1690,14 +1696,14 @@ class Edb(Database):
             else:
                 _poly = self.layout.expanded_extent(
                     net_signals,
-                    self.edb_api.geometry.extent_type.Conforming,
+                    self.core.geometry.extent_type.Conforming,
                     expansion_size,
                     False,
                     use_round_corner,
                     1,
                 )
                 _poly_list = convert_py_list_to_net_list([_poly])
-                _poly = self.edb_api.geometry.polygon_data.get_convex_hull_of_polygons(_poly_list)
+                _poly = self.core.geometry.polygon_data.get_convex_hull_of_polygons(_poly_list)
         return _poly
 
     def _create_conformal(
@@ -1772,7 +1778,7 @@ class Edb(Database):
                             pass
                         finally:
                             unite_polys.extend(list(obj_data))
-            _poly_unite = self.edb_api.geometry.polygon_data.unite(unite_polys)
+            _poly_unite = self.core.geometry.polygon_data.unite(unite_polys)
             if len(_poly_unite) == 1:
                 self.logger.info("Correctly computed Extension at first iteration.")
                 return _poly_unite[0]
@@ -1797,20 +1803,20 @@ class Edb(Database):
                 pd = term._edb_object.GetParameters()[1]
                 locations.append([pd.X.ToDouble(), pd.Y.ToDouble()])
         for point in locations:
-            pointA = self.edb_api.geometry.point_data(
+            pointA = self.core.geometry.point_data(
                 self.edb_value(point[0] - expansion_size),
                 self.edb_value(point[1] - expansion_size),
             )
-            pointB = self.edb_api.geometry.point_data(
+            pointB = self.core.geometry.point_data(
                 self.edb_value(point[0] + expansion_size),
                 self.edb_value(point[1] + expansion_size),
             )
 
             points = Tuple[
-                self.edb_api.geometry.geometry.PointData,
-                self.edb_api.geometry.geometry.PointData,
+                self.core.geometry.geometry.PointData,
+                self.core.geometry.geometry.PointData,
             ](pointA, pointB)
-            _polys.append(self.edb_api.geometry.polygon_data.create_from_bbox(points))
+            _polys.append(self.core.geometry.polygon_data.create_from_bbox(points))
         return _polys
 
     def _create_convex_hull(
@@ -1843,7 +1849,7 @@ class Edb(Database):
         if smart_cut:
             objs_data = self._smart_cut(reference_list, expansion_size)
             _polys.extend(objs_data)
-        _poly = self.edb_api.geometry.polygon_data.get_convex_hull_of_polygons(convert_py_list_to_net_list(_polys))
+        _poly = self.core.geometry.polygon_data.get_convex_hull_of_polygons(convert_py_list_to_net_list(_polys))
         _poly = _poly.Expand(expansion_size, tolerance, round_corner, round_extension)[0]
         return _poly
 
@@ -1978,8 +1984,8 @@ class Edb(Database):
         >>> edb.logger.info("Total legacy cutout time in min %s", end_time)
         >>> edb.nets.plot(signal_list, None, color_by_net=True)
         >>> edb.nets.plot(power_list, None, color_by_net=True)
-        >>> edb.save_edb()
-        >>> edb.close_edb()
+        >>> edb.save()
+        >>> edb.close()
 
 
         """
@@ -2051,12 +2057,12 @@ class Edb(Database):
                     )
                     if self.are_port_reference_terminals_connected():
                         if output_aedb_path:
-                            self.save_edb_as(output_aedb_path)
+                            self.save_as(output_aedb_path)
                         else:
-                            self.save_edb_as(legacy_path)
+                            self.save_as(legacy_path)
                         working_cutout = True
                         break
-                    self.close_edb()
+                    self.close()
                     self.edbpath = legacy_path
                     self.open_edb()
                     i += 1
@@ -2091,8 +2097,8 @@ class Edb(Database):
                     inlcude_voids_in_extents=include_voids_in_extents,
                 )
             if result and not open_cutout_at_end and self.edbpath != legacy_path:
-                self.save_edb()
-                self.close_edb()
+                self.save()
+                self.close()
                 self.edbpath = legacy_path
                 self.open_edb()
             return result
@@ -2416,7 +2422,7 @@ class Edb(Database):
                 pins_to_preserve=pins_to_preserve,
                 inlcude_voids_in_extents=inlcude_voids_in_extents,
             )
-            if extent_type in ["Conforming", self.edb_api.geometry.extent_type.Conforming, 1]:
+            if extent_type in ["Conforming", self.core.geometry.extent_type.Conforming, 1]:
                 if extent_defeature > 0:
                     _poly = _poly.Defeature(extent_defeature)
                 _poly1 = _poly.CreateFromArcs(_poly.GetArcData(), True)
@@ -2681,14 +2687,10 @@ class Edb(Database):
             via.pin.Delete()
         if netlist:
             nets = [net.net_obj for net in temp_edb.layout.nets if net.name in netlist]
-            _poly = temp_edb.layout.expanded_extent(
-                nets, self.edb_api.geometry.extent_type.Conforming, 0.0, True, True, 1
-            )
+            _poly = temp_edb.layout.expanded_extent(nets, self.core.geometry.extent_type.Conforming, 0.0, True, True, 1)
         else:
             nets = [net.api_object for net in temp_edb.layout.nets if "gnd" in net.name.lower()]
-            _poly = temp_edb.layout.expanded_extent(
-                nets, self.edb_api.geometry.extent_type.Conforming, 0.0, True, True, 1
-            )
+            _poly = temp_edb.layout.expanded_extent(nets, self.core.geometry.extent_type.Conforming, 0.0, True, True, 1)
             temp_edb.close_edb()
         if _poly:
             return _poly
@@ -2789,9 +2791,7 @@ class Edb(Database):
             p_missing = [i for i in pinstance_to_add if i.id not in ids]
             self.logger.info("Added {} padstack instances after cutout".format(len(p_missing)))
             for p in p_missing:
-                position = self.edb_api.geometry.point_data(
-                    self.edb_value(p.position[0]), self.edb_value(p.position[1])
-                )
+                position = self.core.geometry.point_data(self.edb_value(p.position[0]), self.edb_value(p.position[1]))
                 net = self.nets.find_or_create_net(p.net_name)
                 rotation = self.edb_value(p.rotation)
                 sign_layers = list(self.stackup.signal_layers.keys())
@@ -2808,7 +2808,7 @@ class Edb(Database):
                 for pad in list(self.padstacks.definitions.keys()):
                     if pad == p.padstack_definition:
                         padstack = self.padstacks.definitions[pad].edb_padstack
-                        padstack_instance = self.edb_api.cell.primitive.padstack_instance.create(
+                        padstack_instance = self.core.cell.primitive.padstack_instance.create(
                             _cutout.GetLayout(),
                             net,
                             p.name,
@@ -2831,7 +2831,7 @@ class Edb(Database):
                     center_y,
                     radius,
                 ) = void_circle.primitive_object.GetParameters(0.0, 0.0, 0.0)
-                cloned_circle = self.edb_api.cell.primitive.circle.create(
+                cloned_circle = self.core.cell.primitive.circle.create(
                     layout,
                     void_circle.layer_name,
                     void_circle.net,
@@ -2841,7 +2841,7 @@ class Edb(Database):
                 )
                 cloned_circle.SetIsNegative(True)
             elif void_circle.type == "Polygon":
-                cloned_polygon = self.edb_api.cell.primitive.polygon.create(
+                cloned_polygon = self.core.cell.primitive.polygon.create(
                     layout,
                     void_circle.layer_name,
                     void_circle.net,
@@ -3458,7 +3458,7 @@ class Edb(Database):
                     self.logger.info("Cutout processed.")
                     old_cell = self.active_cell.FindByName(
                         self.db,
-                        self.edb_api.cell.CellType.CircuitCell,
+                        self.core.cell.CellType.CircuitCell,
                         old_cell_name,
                     )
                     if old_cell:
@@ -3696,6 +3696,7 @@ class Edb(Database):
         Dict[str, :class:`legacy.database.edb_data.siwave_simulation_setup_data.SiwaveSYZSimulationSetup`]
 
         """
+
         setups = {}
         for i in list(self.active_cell.SimulationSetups):
             if i.GetType().ToString().endswith("kHFSS"):
@@ -3708,6 +3709,18 @@ class Edb(Database):
                 setups[i.GetName()] = RaptorXSimulationSetup(self, i)
             elif i.GetType().ToString().endswith("kHFSSPI"):
                 setups[i.GetName()] = HFSSPISimulationSetup(self, i)
+        try:
+            cpa_setup_name = self.active_cell.GetProductProperty(
+                self._edb.ProductId.SIWave, SIwaveProperties.CPA_SIM_NAME
+            )[-1]
+        except:
+            cpa_setup_name = ""
+        if cpa_setup_name:
+            from pyedb.dotnet.database.utilities.siwave_cpa_simulation_setup import (
+                SIWaveCPASimulationSetup,
+            )
+
+            setups[cpa_setup_name] = SIWaveCPASimulationSetup(self, cpa_setup_name)
         return setups
 
     @property

pyedb/generic/design_types.py

@@ -19,6 +19,30 @@
 # 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 TYPE_CHECKING, Literal, Union, overload
+import warnings
+
+from pyedb.generic.grpc_warnings import GRPC_GENERAL_WARNING
+from pyedb.misc.misc import list_installed_ansysem
+
+if TYPE_CHECKING:
+    from pyedb.dotnet.edb import Edb as EdbDotnet
+    from pyedb.grpc.edb import Edb as EdbGrpc
+
+
+@overload
+def Edb(*, grpc: Literal[True], **kwargs) -> "EdbGrpc":
+    ...
+
+
+@overload
+def Edb(*, grpc: Literal[False] = False, **kwargs) -> "EdbDotnet":
+    ...
+
+
+@overload
+def Edb(*, grpc: bool, **kwargs) -> Union["EdbGrpc", "EdbDotnet"]:
+    ...
 
 
 # lazy imports
@@ -234,7 +258,21 @@ def Edb(
 
     """
 
+    if not edbversion:  # pragma: no cover
+        try:
+            version = "20{}.{}".format(list_installed_ansysem()[0][-3:-1], list_installed_ansysem()[0][-1:])
+        except IndexError:
+            raise Exception("No ANSYSEM_ROOTxxx is found.")
+    else:
+        version = edbversion
+
     # Use EDB legacy (default choice)
+    if float(version) >= 2025.2:
+        if not grpc:
+            warnings.warn(GRPC_GENERAL_WARNING, UserWarning)
+    else:
+        if grpc:
+            raise ValueError(f"gRPC flag was enabled however your ANSYS AEDT version {version} is not compatible")
     if grpc:
         from pyedb.grpc.edb import Edb as app
     else:
@@ -243,7 +281,7 @@ def Edb(
         edbpath=edbpath,
         cellname=cellname,
         isreadonly=isreadonly,
-        edbversion=edbversion,
+        edbversion=version,
         isaedtowned=isaedtowned,
         oproject=oproject,
         student_version=student_version,

pyedb/generic/grpc_warnings.py

@@ -0,0 +1,5 @@
+GRPC_GENERAL_WARNING = (
+    "Your ANSYS AEDT version is eligible to gRPC version."
+    "You might consider switching to that version for better user experience."
+    "For more information please check this link: https://edb.docs.pyansys.com/version/dev/grpc_api/index.html"
+)