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

pyedb/dotnet/database/hfss.py

@@ -130,16 +130,16 @@ class EdbHfss(object):
         if not terminal_name:
             terminal_name = generate_unique_name("Terminal_")
         if isinstance(point_on_edge, (list, tuple)):
-            point_on_edge = self._edb.geometry.point_data(
+            point_on_edge = self._edb.Geometry.PointData(
                 self._get_edb_value(point_on_edge[0]), self._get_edb_value(point_on_edge[1])
             )
         if hasattr(prim_id, "GetId"):
             prim = prim_id
         else:
             prim = [i for i in self._pedb.modeler.primitives if i.id == prim_id][0].primitive_object
-        pos_edge = self._edb.cell.terminal.PrimitiveEdge.Create(prim, point_on_edge)
-        pos_edge = convert_py_list_to_net_list(pos_edge, self._edb.cell.terminal.Edge)
-        return self._edb.cell.terminal.EdgeTerminal.Create(
+        pos_edge = self._edb.Cell.Terminal.PrimitiveEdge.Create(prim, point_on_edge)
+        pos_edge = convert_py_list_to_net_list(pos_edge, self._edb.Cell.Terminal.Edge)
+        return self._edb.Cell.Terminal.EdgeTerminal.Create(
             prim.GetLayout(), prim.GetNet(), terminal_name, pos_edge, isRef=is_ref
         )
 
@@ -470,7 +470,7 @@ class EdbHfss(object):
                     if (
                         res
                         and from_layer_pos
-                        and self._edb.cell.terminal.PadstackInstanceTerminal.Create(
+                        and self._edb.Cell.Terminal.PadstackInstanceTerminal.Create(
                             self._active_layout,
                             py_inst.pin.GetNet(),
                             port_name,
@@ -550,9 +550,9 @@ class EdbHfss(object):
             pec_launch_width=pec_launch_width,
         )
         edb_list = convert_py_list_to_net_list(
-            [pos_term._edb_object, neg_term._edb_object], self._edb.cell.terminal.Terminal
+            [pos_term._edb_object, neg_term._edb_object], self._edb.Cell.Terminal.Terminal
         )
-        _edb_boundle_terminal = self._edb.cell.terminal.BundleTerminal.Create(edb_list)
+        _edb_boundle_terminal = self._edb.Cell.Terminal.BundleTerminal.Create(edb_list)
         _edb_boundle_terminal.SetName(port_name)
         pos, neg = list(_edb_boundle_terminal.GetTerminals())
         pos.SetName(port_name + ":T1")
@@ -616,8 +616,8 @@ class EdbHfss(object):
             _port_name = None
             terminals.append(term)
 
-        edb_list = convert_py_list_to_net_list([i._edb_object for i in terminals], self._edb.cell.terminal.Terminal)
-        _edb_bundle_terminal = self._edb.cell.terminal.BundleTerminal.Create(edb_list)
+        edb_list = convert_py_list_to_net_list([i._edb_object for i in terminals], self._edb.Cell.Terminal.Terminal)
+        _edb_bundle_terminal = self._edb.Cell.Terminal.BundleTerminal.Create(edb_list)
         return port_name, BundleWavePort(self._pedb, _edb_bundle_terminal)
 
     def create_hfss_ports_on_padstack(self, pinpos, portname=None):
@@ -640,7 +640,7 @@ class EdbHfss(object):
 
         if not portname:
             portname = generate_unique_name("Port_" + pinpos.GetNet().GetName())
-        edbpointTerm_pos = self._edb.cell.terminal.PadstackInstanceTerminal.Create(
+        edbpointTerm_pos = self._edb.Cell.Terminal.PadstackInstanceTerminal.Create(
             self._active_layout, pinpos.GetNet(), portname, pinpos, toLayer_pos
         )
         if edbpointTerm_pos:
@@ -717,18 +717,18 @@ class EdbHfss(object):
         if not isinstance(terminal_point, list):
             self._logger.error("Terminal point must be a list of float with providing the point location in meter")
             return False
-        terminal_point = self._edb.geometry.point_data(
+        terminal_point = self._edb.Geometry.PointData(
             self._get_edb_value(terminal_point[0]), self._get_edb_value(terminal_point[1])
         )
         if reference_point and isinstance(reference_point, list):
-            reference_point = self._edb.geometry.point_data(
+            reference_point = self._edb.Geometry.PointData(
                 self._get_edb_value(reference_point[0]), self._get_edb_value(reference_point[1])
             )
         if not port_name:
             port_name = generate_unique_name("Port_")
-        edge = self._edb.cell.terminal.PrimitiveEdge.Create(polygon._edb_object, terminal_point)
-        edges = convert_py_list_to_net_list(edge, self._edb.cell.terminal.Edge)
-        edge_term = self._edb.cell.terminal.EdgeTerminal.Create(
+        edge = self._edb.Cell.Terminal.PrimitiveEdge.Create(polygon._edb_object, terminal_point)
+        edges = convert_py_list_to_net_list(edge, self._edb.Cell.Terminal.Edge)
+        edge_term = self._edb.Cell.Terminal.EdgeTerminal.Create(
             polygon._edb_object.GetLayout(), polygon._edb_object.GetNet(), port_name, edges, isRef=False
         )
         if force_circuit_port:
@@ -740,9 +740,9 @@ class EdbHfss(object):
             edge_term.SetImpedance(self._pedb.edb_value(port_impedance))
         edge_term.SetName(port_name)
         if reference_polygon and reference_point:
-            ref_edge = self._edb.cell.terminal.PrimitiveEdge.Create(reference_polygon._edb_object, reference_point)
-            ref_edges = convert_py_list_to_net_list(ref_edge, self._edb.cell.terminal.Edge)
-            ref_edge_term = self._edb.cell.terminal.EdgeTerminal.Create(
+            ref_edge = self._edb.Cell.Terminal.PrimitiveEdge.Create(reference_polygon._edb_object, reference_point)
+            ref_edges = convert_py_list_to_net_list(ref_edge, self._edb.Cell.Terminal.Edge)
+            ref_edge_term = self._edb.Cell.Terminal.EdgeTerminal.Create(
                 reference_polygon._edb_object.GetLayout(),
                 reference_polygon._edb_object.GetNet(),
                 port_name + "_ref",
@@ -981,15 +981,15 @@ class EdbHfss(object):
         """
         if not isinstance(nets, list):
             if isinstance(nets, str):
-                nets = [self._edb.cell.net.find_by_name(self._active_layout, nets)]
-            elif isinstance(nets, self._edb.cell.net.net):
+                nets = [self._edb.Cell.net.find_by_name(self._active_layout, nets)]
+            elif isinstance(nets, self._edb.Cell.net.net):
                 nets = [nets]
         else:
             temp_nets = []
             for nn in nets:
                 if isinstance(nn, str):
-                    temp_nets.append(self._edb.cell.net.find_by_name(self._active_layout, nn))
-                elif isinstance(nn, self._edb.cell.net.net):
+                    temp_nets.append(self._edb.Cell.net.find_by_name(self._active_layout, nn))
+                elif isinstance(nn, self._edb.Cell.net.net):
                     temp_nets.append(nn)
             nets = temp_nets
         port_created = False
@@ -1109,7 +1109,7 @@ class EdbHfss(object):
                 net_polygons = [
                     pp
                     for pp in net.primitives
-                    if pp._edb_object.GetPrimitiveType() == self._edb.cell.primitive.api.PrimitiveType.Polygon
+                    if pp._edb_object.GetPrimitiveType() == self._edb.Cell.Primitive.PrimitiveType.Polygon
                 ]
                 for poly in net_polygons:
                     mid_points = [[arc.mid_point.X.ToDouble(), arc.mid_point.Y.ToDouble()] for arc in poly.arcs]
@@ -1121,8 +1121,8 @@ class EdbHfss(object):
                                 self._logger.info("Terminal {} created".format(term.GetName()))
                                 term.SetIsCircuitPort(True)
                                 terminal_info.append([poly.net.name, mid_point[0], mid_point[1], term.GetName()])
-                                mid_pt_data = self._edb.geometry.point_data(
-                                    self._edb.utility.value(mid_point[0]), self._edb.utility.value(mid_point[1])
+                                mid_pt_data = self._edb.Geometry.PointData(
+                                    self._edb.Utility.Value(mid_point[0]), self._edb.Utility.Value(mid_point[1])
                                 )
                                 ref_prim = [
                                     prim
@@ -1138,8 +1138,8 @@ class EdbHfss(object):
                                         (mid_point[0] + mid_point[0] * 1e-3, mid_point[1] - mid_point[1] * 1e-3),
                                     ]
                                     for new_point in scanning_zone:
-                                        mid_pt_data = self._edb.geometry.point_data(
-                                            self._edb.utility.value(new_point[0]), self._edb.utility.value(new_point[1])
+                                        mid_pt_data = self._edb.Geometry.PointData(
+                                            self._edb.Utility.Value(new_point[0]), self._edb.Utility.Value(new_point[1])
                                         )
                                         ref_prim = [
                                             prim
@@ -1181,7 +1181,7 @@ class EdbHfss(object):
         for lobj in layout_obj_instances.Items:
             lobj_bbox = lobj.GetLayoutInstanceContext().GetBBox(False)
             tuple_list.append(lobj_bbox)
-        _bbox = self._edb.geometry.polygon_data.get_bbox_of_boxes(tuple_list)
+        _bbox = self._edb.Geometry.PolygonData.GetBBoxOfBoxes(convert_py_list_to_net_list(tuple_list))
         layout_bbox = [
             round(_bbox.Item1.X.ToDouble(), digit_resolution),
             round(_bbox.Item1.Y.ToDouble(), digit_resolution),
@@ -1209,13 +1209,13 @@ class EdbHfss(object):
                 "Configure HFSS extent requires edb_data.simulation_configuration.SimulationConfiguration object"
             )
             return False
-        hfss_extent = self._edb.utility.utility.HFSSExtentInfo()
+        hfss_extent = self._edb.Utility.HFSSExtentInfo()
         if simulation_setup.radiation_box == RadiationBoxType.BoundingBox:
-            hfss_extent.ExtentType = self._edb.utility.utility.HFSSExtentInfoType.BoundingBox
+            hfss_extent.ExtentType = self._edb.Utility.HFSSExtentInfoType.BoundingBox
         elif simulation_setup.radiation_box == RadiationBoxType.Conformal:
-            hfss_extent.ExtentType = self._edb.utility.utility.HFSSExtentInfoType.Conforming
+            hfss_extent.ExtentType = self._edb.Utility.HFSSExtentInfoType.Conforming
         else:
-            hfss_extent.ExtentType = self._edb.utility.utility.HFSSExtentInfoType.ConvexHull
+            hfss_extent.ExtentType = self._edb.Utility.HFSSExtentInfoType.ConvexHull
         hfss_extent.DielectricExtentSize = convert_pytuple_to_nettuple(
             (simulation_setup.dielectric_extent, simulation_setup.use_dielectric_extent_multiple)
         )
@@ -1346,7 +1346,7 @@ class EdbHfss(object):
         except Exception as err:
             self._logger.error("Exception in Sweep configuration: {0}".format(err))
 
-        sim_setup = self._edb.utility.utility.HFSSSimulationSetup(simsetup_info)
+        sim_setup = self._edb.Utility.HFSSSimulationSetup(simsetup_info)
         for setup in self._layout.cell.SimulationSetups:
             self._layout.cell.DeleteSimulationSetup(setup.GetName())
             self._logger.warning("Setup {} has been deleted".format(setup.GetName()))
@@ -1401,7 +1401,7 @@ class EdbHfss(object):
         l_inst = layout.GetLayoutInstance()
 
         for inst in simulation_setup.components:  # pragma: no cover
-            comp = self._pedb.core.cell.hierarchy.component.FindByName(layout, inst)
+            comp = self._pedb.core.Cell.Hierarchy.Component.FindByName(layout, inst)
             if comp.IsNull():
                 continue
 
@@ -1416,7 +1416,7 @@ class EdbHfss(object):
                 pin_list = [
                     obj
                     for obj in list(comp.LayoutObjs)
-                    if obj.GetObjType() == self._edb.cell.layout_object_type.PadstackInstance
+                    if obj.GetObjType() == self._edb.Cell.LayoutObjectType.PadstackInstance
                 ]
                 for pin in pin_list:
                     loi = l_inst.GetLayoutObjInstance(pin, None)
@@ -1473,13 +1473,11 @@ class EdbHfss(object):
             cmp_names = []
         ii = 0
         for cc in cmp_names:
-            cmp = self._pedb.core.cell.hierarchy.component.FindByName(self._active_layout, cc)
+            cmp = self._pedb.core.Cell.Hierarchy.Component.FindByName(self._active_layout, cc)
             if cmp.IsNull():
                 self._logger.warning("RenamePorts: could not find component {0}".format(cc))
                 continue
-            terms = [
-                obj for obj in list(cmp.LayoutObjs) if obj.GetObjType() == self._edb.cell.layout_object_type.Terminal
-            ]
+            terms = [obj for obj in list(cmp.LayoutObjs) if obj.GetObjType() == self._edb.Cell.LayoutObjType.Terminal]
             for nn in net_names:
                 for tt in [term for term in terms if term.GetNet().GetName() == nn]:
                     if not tt.SetImpedance(self._pedb.edb_value("50ohm")):
@@ -1491,9 +1489,9 @@ class EdbHfss(object):
                 # Set the Radial Extent Factor
                 typ = cmp.GetComponentType()
                 if typ in [
-                    self._edb.definition.ComponentType.Other,
-                    self._edb.definition.ComponentType.IC,
-                    self._edb.definition.ComponentType.IO,
+                    self._edb.Definition.ComponentType.Other,
+                    self._edb.Definition.ComponentType.IC,
+                    self._edb.Definition.ComponentType.IO,
                 ]:
                     cmp_prop = cmp.GetComponentProperty().Clone()
                     (
@@ -1512,14 +1510,14 @@ class EdbHfss(object):
                             "'PEC Launch Width'='0mm')"
                         )
                         for tt in terms:
-                            tt.SetProductSolverOption(self._edb.core.ProductId.Designer, "HFSS", option)
+                            tt.SetProductSolverOption(self._edb.ProductId.Designer, "HFSS", option)
         return True
 
     def _get_terminals_bbox(self, comp, l_inst, terminals_only):
         terms_loi = []
         if terminals_only:
             term_list = [
-                obj for obj in list(comp.LayoutObjs) if obj.GetObjType() == self._edb.cell.layout_object_type.Terminal
+                obj for obj in list(comp.LayoutObjs) if obj.GetObjType() == self._edb.Cell.LayoutObjectType.Terminal
             ]
             for tt in term_list:
                 success, p_inst, lyr = tt.GetParameters()
@@ -1530,7 +1528,7 @@ class EdbHfss(object):
             pin_list = [
                 obj
                 for obj in list(comp.LayoutObjs)
-                if obj.GetObjType() == self._edb.cell.layout_object_type.PadstackInstance
+                if obj.GetObjType() == self._edb.Cell.LayoutObjectType.PadstackInstance
             ]
             for pi in pin_list:
                 loi = l_inst.GetLayoutObjInstance(pi, None)
@@ -1643,9 +1641,9 @@ class EdbHfss(object):
         if positive_pin and negative_pin:
             positive_pin_term = self._pedb.components._create_terminal(positive_pin)
             negative_pin_term = self._pedb.components._create_terminal(negative_pin)
-            positive_pin_term.SetBoundaryType(self._edb.cell.terminal.BoundaryType.RlcBoundary)
-            negative_pin_term.SetBoundaryType(self._edb.cell.terminal.BoundaryType.RlcBoundary)
-            rlc = self._edb.utility.utility.Rlc()
+            positive_pin_term.SetBoundaryType(self._edb.Cell.Terminal.BoundaryType.RlcBoundary)
+            negative_pin_term.SetBoundaryType(self._edb.Cell.Terminal.BoundaryType.RlcBoundary)
+            rlc = self._edb.Utility.Rlc()
             rlc.IsParallel = True
             rlc.REnabled = True
             rlc.LEnabled = True

pyedb/dotnet/database/layout_validation.py

@@ -25,6 +25,7 @@ import re
 from pyedb.dotnet.database.edb_data.padstacks_data import EDBPadstackInstance
 from pyedb.dotnet.database.edb_data.primitives_data import Primitive
 from pyedb.generic.general_methods import generate_unique_name
+from pyedb.misc.decorators import execution_timer
 
 
 class LayoutValidation:
@@ -33,6 +34,7 @@ class LayoutValidation:
     def __init__(self, pedb):
         self._pedb = pedb
 
+    @execution_timer("dc_shorts")
     def dc_shorts(self, net_list=None, fix=False):
         """Find DC shorts on layout.
 
@@ -120,6 +122,7 @@ class LayoutValidation:
                         # i.net = temp_name
         return dc_shorts
 
+    @execution_timer("disjoint_nets")
     def disjoint_nets(
         self,
         net_list=None,
@@ -154,10 +157,9 @@ class LayoutValidation:
 
         >>> renamed_nets = edb.layout_validation.disjoint_nets(["GND","Net2"])
         """
-        timer_start = self._pedb._logger.reset_timer()
 
         if not net_list:
-            net_list = list(self._pedb.nets.keys())
+            net_list = list(self._pedb.nets.nets.keys())
         elif isinstance(net_list, str):
             net_list = [net_list]
         _objects_list = {}
@@ -176,7 +178,6 @@ class LayoutValidation:
                 _padstacks_list[n_name] = [pad]
         new_nets = []
         disjoints_objects = []
-        self._pedb._logger.reset_timer()
         for net in net_list:
             net_groups = []
             obj_dict = {}
@@ -253,11 +254,10 @@ class LayoutValidation:
                                 except KeyError:
                                     pass
                             disjoints_objects.extend(disjoints)
-        self._pedb._logger.info("Found {} objects in {} new nets.".format(len(disjoints_objects), len(new_nets)))
-        self._pedb._logger.info_timer("Disjoint Cleanup Completed.", timer_start)
-
+        self._pedb.logger.info("Found {} objects in {} new nets.".format(len(disjoints_objects), len(new_nets)))
         return new_nets
 
+    @execution_timer("self_intersections")
     def fix_self_intersections(self, net_list=None):
         """Find and fix self intersections from a given netlist.
 
@@ -279,11 +279,12 @@ class LayoutValidation:
             if prim.net_name in net_list:
                 new_prims.extend(prim.fix_self_intersections())
         if new_prims:
-            self._pedb._logger.info("Self-intersections detected and removed.")
+            self._pedb.logger.info("Self-intersections detected and removed.")
         else:
-            self._pedb._logger.info("Self-intersection not found.")
+            self._pedb.logger.info("Self-intersection not found.")
         return True
 
+    @execution_timer("illegal_net_names")
     def illegal_net_names(self, fix=False):
         """Find and fix illegal net names."""
         pattern = r"[\(\)\\\/:;*?<>\'\"|`~$]"
@@ -298,9 +299,10 @@ class LayoutValidation:
                     new_name = re.sub(pattern, "_", net)
                     val.name = new_name
 
-        self._pedb._logger.info("Found {} illegal net names.".format(len(renamed_nets)))
+        self._pedb.logger.info("Found {} illegal net names.".format(len(renamed_nets)))
         return
 
+    @execution_timer("illegal_rlc_values")
     def illegal_rlc_values(self, fix=False):
         """Find and fix RLC illegal values."""
 
@@ -320,9 +322,10 @@ class LayoutValidation:
                     if fix:
                         v.rlc_values = [0, 1, 0]
 
-            self._pedb._logger.info(f"Found {len(temp)} {name} have no value.")
+            self._pedb.logger.info(f"Found {len(temp)} {name} have no value.")
         return
 
+    @execution_timer("padstacks_no_name")
     def padstacks_no_name(self, fix=False):
         """Find and fix padstacks without aedt_name."""
         pds = self._pedb.layout.padstack_instances
@@ -332,4 +335,4 @@ class LayoutValidation:
                 counts += 1
                 if fix:
                     obj.aedt_name = f"via_{obj.id}"
-        self._pedb._logger.info(f"Found {counts}/{len(pds)} padstacks have no name.")
+        self._pedb.logger.info(f"Found {counts}/{len(pds)} padstacks have no name.")

pyedb/dotnet/database/materials.py

@@ -111,7 +111,7 @@ class Material(object):
 
     def __init__(self, edb: Edb, material_def):
         self.__edb: Edb = edb
-        self.__edb_definition = edb.core.definition
+        self.__edb_definition = edb.core.Definition
         self.__name: str = material_def.GetName()
         self.__material_def = material_def
         self.__dc_model = material_def.GetDielectricMaterialModel()
@@ -191,12 +191,6 @@ class Material(object):
         )
         return self.dielectric_loss_tangent
 
-    @property
-    def dielectric_loss_tangent(self):
-        """Get material loss tangent."""
-        material_property_id = self.__edb_definition.MaterialPropertyId.DielectricLossTangent
-        return self.__property_value(material_property_id)
-
     @loss_tangent.setter
     def loss_tangent(self, value):
         """Set material loss tangent."""
@@ -205,11 +199,16 @@ class Material(object):
             "Use property dielectric_loss_tangent instead.",
             DeprecationWarning,
         )
-        return self.dielectric_loss_tangent(value)
+        self.dielectric_loss_tangent = value
+
+    @property
+    def dielectric_loss_tangent(self):
+        """Get material loss tangent."""
+        material_property_id = self.__edb_definition.MaterialPropertyId.DielectricLossTangent
+        return self.__property_value(material_property_id)
 
     @dielectric_loss_tangent.setter
     def dielectric_loss_tangent(self, value):
-        """Set material loss tangent."""
         edb_value = self.__edb_value(value)
         material_property_id = self.__edb_definition.MaterialPropertyId.DielectricLossTangent
         self.__material_def.SetProperty(material_property_id, edb_value)
@@ -553,7 +552,7 @@ class Materials(object):
 
     def __init__(self, edb: Edb):
         self.__edb = edb
-        self.__edb_definition = edb.core.definition
+        self.__edb_definition = edb.core.Definition
         self.__syslib = os.path.join(self.__edb.base_path, "syslib")
 
     def __contains__(self, item):
@@ -575,7 +574,7 @@ class Materials(object):
         """Get materials."""
         materials = {
             material_def.GetName(): Material(self.__edb, material_def)
-            for material_def in list(self.__edb.active_db.MaterialDefs)
+            for material_def in list(self.__edb._db.MaterialDefs)
         }
         return materials