pyedb 0.47.1__py3-none-any.whl → 0.49.0__py3-none-any.whl

pyedb/dotnet/database/definition/package_def.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 warnings
 
 from pyedb.dotnet.database.geometry.polygon_data import PolygonData
 from pyedb.dotnet.database.utilities.obj_base import ObjBase
@@ -105,15 +106,29 @@ class PackageDef(ObjBase):
         self._edb_object.SetMaximumPower(value)
 
     @property
-    def therm_cond(self):
-        """Thermal conductivity of the package."""
+    def thermal_conductivity(self):
+        """Adding this property for compatibility with grpc."""
         return self._edb_object.GetTherm_Cond().ToDouble()
 
-    @therm_cond.setter
-    def therm_cond(self, value):
+    @thermal_conductivity.setter
+    def thermal_conductivity(self, value):
         value = self._pedb.edb_value(value)
         self._edb_object.SetTherm_Cond(value)
 
+    @property
+    def therm_cond(self):
+        """Thermal conductivity of the package.
+
+        ..deprecated:: 0.48.0
+           Use: func:`thermal_conductivity` property instead.
+        """
+        warnings.warn("Use property thermal_conductivity instead.", DeprecationWarning)
+        return self.thermal_conductivity
+
+    @therm_cond.setter
+    def therm_cond(self, value):
+        self.thermal_conductivity = value
+
     @property
     def theta_jb(self):
         """Theta Junction-to-Board of the package."""
@@ -153,10 +168,19 @@ class PackageDef(ObjBase):
         heatsink.fin_orientation = fin_orientation
         heatsink.fin_spacing = fin_spacing
         heatsink.fin_thickness = fin_thickness
-        self._edb_object.SetHeatSink(heatsink._edb_object)
+        return self._edb_object.SetHeatSink(heatsink._edb_object)
 
     @property
     def heatsink(self):
+        """Component heatsink.
+
+        ..deprecated:: 0.48.0
+           Use: func:`heat_sink` property instead.
+        """
+        return self.heat_sink
+
+    @property
+    def heat_sink(self):
         """Component heatsink."""
         from pyedb.dotnet.database.utilities.heatsink import HeatSink
 

pyedb/dotnet/database/dotnet/database.py

@@ -484,6 +484,24 @@ class CellClassDotNet:
 
         return PrimitiveDotNet(self._app)
 
+    @property
+    def simulation_setups(self):
+        return self._app.setups
+
+    def get_all_variable_names(self):
+        """Method added for compatibility with grpc.
+
+        Returns
+        -------
+        List[Str]
+            List of variables name.
+
+        """
+        return list(self._app.variable_exists("")[1].GetAllVariableNames())
+
+    def get_variable_value(self, variable_name):
+        return self._app.variables[variable_name]
+
 
 class UtilityDotNet:
     """Utility Edb class."""

pyedb/dotnet/database/edb_data/padstacks_data.py

@@ -1261,6 +1261,8 @@ class EDBPadstackInstance(Primitive):
         """
         terminal = self.create_terminal(name)
         if reference:
+            if isinstance(reference, tuple):
+                reference = reference[1]
             ref_terminal = reference.create_terminal(terminal.name + "_ref")
             if reference._edb_object.ToString() == "PinGroup":
                 is_circuit_port = True
@@ -1463,6 +1465,19 @@ class EDBPadstackInstance(Primitive):
         else:
             return self._edb_padstackinstance.SetBackDrillParameters(layer, val, False)
 
+    @property
+    def backdrill_type(self):
+        """Adding grpc compatibility. DotNet is supporting only layer drill type with adding stub length."""
+        return "layer_drill"
+
+    def get_back_drill_by_layer(self):
+        params = self.backdrill_parameters["from_bottom"]
+        return (
+            params["drill_to_layer"],
+            round(self._pedb.edb_value(params["stub_length"]).ToDouble(), 6),
+            round(self._pedb.edb_value(params["diameter"]).ToDouble(), 6),
+        )
+
     @property
     def backdrill_bottom(self):
         """Backdrill layer from bottom.
@@ -1539,6 +1554,11 @@ class EDBPadstackInstance(Primitive):
                 False,
             )
 
+    def set_back_drill_by_layer(self, drill_to_layer, diameter, offset):
+        """Method added to bring compatibility with grpc."""
+
+        self.set_backdrill_bottom(drill_depth=drill_to_layer.name, drill_diameter=diameter, offset=offset)
+
     def set_backdrill_bottom(self, drill_depth, drill_diameter, offset=0.0):
         """Set backdrill from bottom.
 
@@ -1676,9 +1696,9 @@ class EDBPadstackInstance(Primitive):
         out = self._edb_padstackinstance.GetPositionAndRotationValue()
         if self._edb_padstackinstance.GetComponent():
             out2 = self._edb_padstackinstance.GetComponent().GetTransform().TransformPoint(out[1])
-            self._position = [out2.X.ToDouble(), out2.Y.ToDouble()]
+            self._position = [round(out2.X.ToDouble(), 6), round(out2.Y.ToDouble(), 6)]
         elif out[0]:
-            self._position = [out[1].X.ToDouble(), out[1].Y.ToDouble()]
+            self._position = [round(out[1].X.ToDouble(), 6), round(out[1].Y.ToDouble(), 6)]
         return self._position
 
     @position.setter
@@ -1704,7 +1724,7 @@ class EDBPadstackInstance(Primitive):
         out = self._edb_padstackinstance.GetPositionAndRotationValue()
 
         if out[0]:
-            return out[2].ToDouble()
+            return round(out[2].ToDouble(), 6)
 
     @property
     def name(self):
@@ -1874,7 +1894,7 @@ class EDBPadstackInstance(Primitive):
             Lower elavation of the placement layer.
         """
         try:
-            return self._edb_padstackinstance.GetGroup().GetPlacementLayer().Clone().GetLowerElevation()
+            return round(self._edb_padstackinstance.GetGroup().GetPlacementLayer().Clone().GetLowerElevation(), 6)
         except AttributeError:  # pragma: no cover
             return None
 
@@ -1888,7 +1908,7 @@ class EDBPadstackInstance(Primitive):
            Upper elevation of the placement layer.
         """
         try:
-            return self._edb_padstackinstance.GetGroup().GetPlacementLayer().Clone().GetUpperElevation()
+            return round(self._edb_padstackinstance.GetGroup().GetPlacementLayer().Clone().GetUpperElevation(), 6)
         except AttributeError:  # pragma: no cover
             return None
 

pyedb/dotnet/database/edb_data/ports.py

@@ -54,6 +54,16 @@ class GapPort(EdgeTerminal):
         """Magnitude."""
         return self._edb_object.GetSourceAmplitude().ToDouble()
 
+    @property
+    def source_amplitude(self):
+        """Property added for grpc compatibility"""
+        return self.magnitude
+
+    @property
+    def source_phase(self):
+        """Property added for grpc compatibility"""
+        return self.phase
+
     @property
     def phase(self):
         """Phase."""
@@ -77,6 +87,10 @@ class GapPort(EdgeTerminal):
             self._edb_object.GetPortPostProcessingProp().RenormalizionZ0.ToComplex().Item2,
         )
 
+    @property
+    def renormalization_impedance(self):
+        return self.renormalize_z0[0]
+
 
 class CircuitPort(GapPort):
     """Manages gap port properties.

pyedb/dotnet/database/edb_data/utilities.py

@@ -69,7 +69,7 @@ class EDBStatistics(object):
 
     @property
     def stackup_thickness(self):
-        return self._stackup_thickness
+        return round(self._stackup_thickness, 6)
 
     @stackup_thickness.setter
     def stackup_thickness(self, value):

pyedb/dotnet/database/geometry/polygon_data.py

@@ -20,6 +20,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 from typing import Union
+import warnings
 
 from pyedb.dotnet.database.general import convert_py_list_to_net_list
 from pyedb.dotnet.database.geometry.point_data import PointData
@@ -82,7 +83,7 @@ class PolygonData:
         list[list[float]]
         """
         return [
-            [self._pedb.edb_value(i.X).ToDouble(), self._pedb.edb_value(i.Y).ToDouble()]
+            (self._pedb.edb_value(i.X).ToDouble(), self._pedb.edb_value(i.Y).ToDouble())
             for i in list(self._edb_object.Points)
         ]
 
@@ -132,10 +133,22 @@ class PolygonData:
         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:
+    def is_inside(self, x: Union[str, float], y: Union[str, float] = None) -> bool:
         """Determines whether a point is inside the polygon."""
+        if isinstance(x, list) and len(x) == 2:
+            y = x[1]
+            x = x[0]
         return self._edb_object.PointInPolygon(self._pedb.point_data(x, y))
 
+    def point_in_polygon(self, x: Union[str, float], y: Union[str, float] = None) -> bool:
+        """Determines whether a point is inside the polygon.
+
+        ..deprecated:: 0.48.0
+           Use: func:`is_inside` instead.
+        """
+        warnings.warn("Use method is_inside instead", DeprecationWarning)
+        return self.is_inside(x, y)
+
     def get_point(self, index):
         """Gets the point at the index as a PointData object."""
         edb_object = self._edb_object.GetPoint(index)

pyedb/dotnet/database/hfss.py

@@ -429,7 +429,7 @@ class EdbHfss(object):
             source_name,
         )
 
-    def create_coax_port_on_component(self, ref_des_list, net_list):
+    def create_coax_port_on_component(self, ref_des_list, net_list, delete_existing_terminal=False):
         """Create a coaxial port on a component or component list on a net or net list.
            The name of the new coaxial port is automatically assigned.
 
@@ -441,6 +441,10 @@ class EdbHfss(object):
         net_list : list, str
             List of one or more nets.
 
+        delete_existing_terminal : bool
+            Only active with grpc version. This argument is added only to ensure compatibility between DotNet and grpc.
+
+
         Returns
         -------
         bool
@@ -448,6 +452,8 @@ class EdbHfss(object):
 
         """
         coax = []
+        if delete_existing_terminal:
+            self._pedb.logger.warning(f"flag delete_existing_terminal is set to True but is only supported with grpc.")
         if not isinstance(ref_des_list, list):
             ref_des_list = [ref_des_list]
         if not isinstance(net_list, list):
@@ -1234,6 +1240,10 @@ class EdbHfss(object):
         self._layout.cell.SetHFSSExtentInfo(hfss_extent)  # returns void
         return True
 
+    def add_setup(self, name=None):
+        """Adding method for grpc compatibility"""
+        return self._pedb.create_hfss_setup(name=name)
+
     def configure_hfss_analysis_setup(self, simulation_setup=None):
         """
         Configure HFSS analysis setup.

pyedb/dotnet/database/materials.py

@@ -116,6 +116,22 @@ class Material(object):
         self.__material_def = material_def
         self.__dc_model = material_def.GetDielectricMaterialModel()
 
+        self._pedb = edb
+        self._edb_object = material_def
+        definition = self.__edb_definition
+        self.material_property_id_mapping = {
+            "conductivity": definition.MaterialPropertyId.Conductivity,
+            "permittivity": definition.MaterialPropertyId.Permittivity,
+            "dielectric_loss_tangent": definition.MaterialPropertyId.DielectricLossTangent,
+            "magnetic_loss_tangent": definition.MaterialPropertyId.MagneticLossTangent,
+            "mass_density": definition.MaterialPropertyId.MassDensity,
+            "permeability": definition.MaterialPropertyId.Permeability,
+            "poisson_ratio": definition.MaterialPropertyId.PoissonsRatio,
+            "specific_heat": definition.MaterialPropertyId.SpecificHeat,
+            "thermal_conductivity": definition.MaterialPropertyId.ThermalConductivity,
+            "thermal_expansion_coefficient": definition.MaterialPropertyId.ThermalExpansionCoefficient,
+        }
+
     @property
     def name(self):
         """Material name."""
@@ -442,6 +458,68 @@ class Material(object):
     #     # Trigger get value on the property
     #     _ = getattr(self, name)
 
+    def set_thermal_modifier(
+        self,
+        property_name: str,
+        basic_quadratic_temperature_reference: float = 21,
+        basic_quadratic_c1: float = 0.1,
+        basic_quadratic_c2: float = 0.1,
+        advanced_quadratic_lower_limit: float = -270,
+        advanced_quadratic_upper_limit: float = 1001,
+        advanced_quadratic_auto_calculate: bool = False,
+        advanced_quadratic_lower_constant: float = 1.1,
+        advanced_quadratic_upper_constant: float = 1.1,
+    ):
+        """Sets the material property thermal modifier of a given material property.
+
+        Parameters
+        ----------
+        property_name : str
+            Name of the property to modify.
+        basic_quadratic_temperature_reference : float, optional
+            The TempRef value in the quadratic model.
+        basic_quadratic_c1 : float, optional
+            The C1 value in the quadratic model.
+        basic_quadratic_c2 : float, optional
+            The C2 value in the quadratic model.
+        advanced_quadratic_lower_limit : float, optional
+            The lower temperature limit where the quadratic model is valid.
+        advanced_quadratic_upper_limit : float, optional
+            The upper temperature limit where the quadratic model is valid.
+        advanced_quadratic_auto_calculate : bool, optional
+             The flag indicating whether or the LowerConstantThermalModifierVal and UpperConstantThermalModifierVal
+             values should be auto calculated.
+        advanced_quadratic_lower_constant : float, optional
+            The constant thermal modifier value for temperatures lower than LowerConstantThermalModifierVal.
+        advanced_quadratic_upper_constant : float, optional
+            The constant thermal modifier value for temperatures greater than UpperConstantThermalModifierVal.
+
+        Returns
+        -------
+
+        """
+        _edb = self._pedb._edb
+        basic = _edb.Utility.BasicQuadraticParams(
+            _edb.Utility.Value(basic_quadratic_temperature_reference),
+            _edb.Utility.Value(basic_quadratic_c1),
+            _edb.Utility.Value(basic_quadratic_c2),
+        )
+        advanced = _edb.Utility.AdvancedQuadraticParams(
+            _edb.Utility.Value(advanced_quadratic_lower_limit),
+            _edb.Utility.Value(advanced_quadratic_upper_limit),
+            advanced_quadratic_auto_calculate,
+            _edb.Utility.Value(advanced_quadratic_lower_constant),
+            _edb.Utility.Value(advanced_quadratic_upper_constant),
+        )
+
+        thermal_modifier = _edb.Definition.MaterialPropertyThermalModifier(basic, advanced)
+        if not self.__material_def.SetThermalModifier(
+            self.material_property_id_mapping[property_name], thermal_modifier
+        ):
+            raise ValueError(f"Fail to set thermal modifier for property {property_name}")
+        else:
+            return True
+
 
 class Materials(object):
     """Manages EDB methods for material management accessible from `Edb.materials` property."""

pyedb/dotnet/database/modeler.py

@@ -455,9 +455,16 @@ class Modeler(object):
                 xcoeff = str(xcoeff)
             return xcoeff, ycoeff
 
+        from pyedb.dotnet.database.edb_data.primitives_data import EdbPolygon
+
+        if isinstance(selection_polygon, EdbPolygon):
+            selection_polygon = selection_polygon._edb_object
+        if isinstance(polygon, EdbPolygon):
+            polygon = polygon._edb_object
+
         selection_polygon_data = selection_polygon.GetPolygonData()
-        poligon_data = polygon.GetPolygonData()
-        bound_center = poligon_data.GetBoundingCircleCenter()
+        polygon_data = polygon.GetPolygonData()
+        bound_center = polygon_data.GetBoundingCircleCenter()
         bound_center2 = selection_polygon_data.GetBoundingCircleCenter()
         center = [bound_center.X.ToDouble(), bound_center.Y.ToDouble()]
         center2 = [bound_center2.X.ToDouble(), bound_center2.Y.ToDouble()]
@@ -471,7 +478,7 @@ class Modeler(object):
         prev_point = None
         while continue_iterate:
             try:
-                point = poligon_data.GetPoint(i)
+                point = polygon_data.GetPoint(i)
                 if prev_point != point:
                     check_inside = selection_polygon_data.PointInPolygon(point)
                     if check_inside:
@@ -481,14 +488,14 @@ class Modeler(object):
                             point.X.ToString() + "{}*{}".format(xcoeff, offset_name),
                             point.Y.ToString() + "{}*{}".format(ycoeff, offset_name),
                         )
-                        poligon_data.SetPoint(i, new_points)
+                        polygon_data.SetPoint(i, new_points)
                     prev_point = point
                     i += 1
                 else:
                     continue_iterate = False
             except:
                 continue_iterate = False
-        polygon.SetPolygonData(poligon_data)
+        polygon.SetPolygonData(polygon_data)
         return True
 
     def _create_path(
@@ -1317,7 +1324,7 @@ class Modeler(object):
         stat_model.num_resistors = len(self._pedb.components.resistors)
         stat_model.num_inductors = len(self._pedb.components.inductors)
         bbox = self._pedb._hfss.get_layout_bounding_box(self._active_layout)
-        stat_model._layout_size = bbox[2] - bbox[0], bbox[3] - bbox[1]
+        stat_model._layout_size = round(bbox[2] - bbox[0], 6), round(bbox[3] - bbox[1], 6)
         stat_model.num_discrete_components = (
             len(self._pedb.components.Others) + len(self._pedb.components.ICs) + len(self._pedb.components.IOs)
         )
@@ -1328,7 +1335,7 @@ class Modeler(object):
         stat_model.num_traces = len(self._pedb.modeler.paths)
         stat_model.num_polygons = len(self._pedb.modeler.polygons)
         stat_model.num_vias = len(self._pedb.padstacks.instances)
-        stat_model.stackup_thickness = self._pedb.stackup.get_layout_thickness()
+        stat_model.stackup_thickness = round(self._pedb.stackup.get_layout_thickness(), 6)
         if evaluate_area:
             outline_surface = stat_model.layout_size[0] * stat_model.layout_size[1]
             if net_list:
@@ -1343,8 +1350,8 @@ class Modeler(object):
                             surface += prim.length * prim.width
                         if prim.type == "Polygon":
                             surface += prim.polygon_data._edb_object.Area()
-                            stat_model.occupying_surface[layer] = surface
-                            stat_model.occupying_ratio[layer] = surface / outline_surface
+                            stat_model.occupying_surface[layer] = round(surface, 6)
+                            stat_model.occupying_ratio[layer] = round(surface / outline_surface, 6)
         return stat_model
 
     def create_bondwire(
@@ -1361,6 +1368,7 @@ class Modeler(object):
         end_y,
         net,
         bondwire_type="jedec4",
+        start_cell_instance_name=None,
     ):
         """Create a bondwire object.
 
@@ -1390,13 +1398,16 @@ class Modeler(object):
             Y value of end point.
         net : str or :class:`Net <ansys.edb.net.Net>` or None
             Net of the Bondwire.
+        start_cell_instance_name : None
+            Added for grpc compatibility.
 
         Returns
         -------
         :class:`pyedb.dotnet.database.dotnet.primitive.BondwireDotNet`
             Bondwire object created.
         """
-
+        if start_cell_instance_name:
+            self._pedb.logger.warning(f"start_cell_instance_name {start_cell_instance_name} is only valid with grpc.")
         return Bondwire(
             pedb=self._pedb,
             bondwire_type=bondwire_type,

pyedb/dotnet/database/padstack.py

@@ -629,9 +629,11 @@ class EdbPadstacks(object):
         if "PadstackDef" in str(type(pin)):
             padparams = pin.GetData().GetPadParametersValue(layername, self.int_to_pad_type(pad_type))
         else:
-            padparams = self._edb.definition.PadstackDefData(pin.GetPadstackDef().GetData()).GetPadParametersValue(
-                layername, self.int_to_pad_type(pad_type)
-            )
+            if not isinstance(pin, EDBPadstackInstance):
+                pin = EDBPadstackInstance(pin, self._pedb)
+            padparams = self._edb.definition.PadstackDefData(
+                pin._edb_object.GetPadstackDef().GetData()
+            ).GetPadParametersValue(layername, self.int_to_pad_type(pad_type))
         if padparams[2]:
             geometry_type = int(padparams[1])
             parameters = [i.ToString() for i in padparams[2]]
@@ -646,7 +648,7 @@ class EdbPadstacks(object):
                 )
             else:
                 padparams = self._edb.definition.PadstackDefData(
-                    pin.GetPadstackDef().GetData()
+                    pin._edb_object.GetPadstackDef().GetData()
                 ).GetPolygonalPadParameters(layername, self.int_to_pad_type(pad_type))
 
             if padparams[0]:
@@ -1076,7 +1078,7 @@ class EdbPadstacks(object):
         return padstackname
 
     def _get_pin_layer_range(self, pin):
-        res, fromlayer, tolayer = pin.GetLayerRange()
+        res, fromlayer, tolayer = pin._edb_object.GetLayerRange()
         if res:
             return fromlayer, tolayer
         else:

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

@@ -47,6 +47,20 @@ class MeshOperation(object):
             "kNumMeshOpTypes": self._edb_object.TMeshOpType.kNumMeshOpTypes,
         }
 
+    @property
+    def net_layer_info(self):
+        """Adding property for grpc compatibility.
+
+        Returns
+        -------
+        The tuple is in this form: (net_name, layer_name, is_sheet)``.
+        """
+        layer_inf = []
+        for net_name, mesh_op in self.nets_layers_list.items():
+            for layer in mesh_op:
+                layer_inf.append((net_name, layer, True))
+        return layer_inf
+
     @property
     def enabled(self):
         """Whether if mesh operation is enabled.
@@ -220,6 +234,11 @@ class LengthMeshOperation(MeshOperation, object):
         """
         return self._edb_object.MaxLength
 
+    @property
+    def restrict_max_length(self):
+        """Adding property for grpc compatibility."""
+        return self.restrict_length
+
     @property
     def restrict_length(self):
         """Whether to restrict length of elements.
@@ -286,6 +305,11 @@ class SkinDepthMeshOperation(MeshOperation, object):
     def surface_triangle_length(self, value):
         self._edb_object.SurfTriLength = value
 
+    @property
+    def number_of_layers(self):
+        """Adding property for grpc compatibility."""
+        return self.number_of_layer_elements
+
     @property
     def number_of_layer_elements(self):
         """Number of layer elements.