pyedb 0.50.1__py3-none-any.whl → 0.51.2__py3-none-any.whl

pyedb/__init__.py

@@ -44,7 +44,7 @@ deprecation_warning()
 #
 
 pyedb_path = os.path.dirname(__file__)
-__version__ = "0.50.1"
+__version__ = "0.51.2"
 version = __version__
 
 #

pyedb/configuration/cfg_ports_sources.py

@@ -19,7 +19,6 @@
 # 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 os
 
 import numpy as np
 
@@ -33,29 +32,11 @@ from pyedb.dotnet.database.geometry.point_data import PointData
 class CfgTerminalInfo(CfgBase):
     CFG_TERMINAL_TYPES = ["pin", "net", "pin_group", "nearest_pin", "coordinates"]
 
-    class Grpc:
-        def __init__(self, parent):
-            self.parent = parent
-            self._pedb = parent._pedb
-
-        def update_contact_radius(self, radius):
-            from ansys.edb.core.utility.value import Value as GrpcValue
-
-            self.parent.contact_radius = GrpcValue(radius).value
-
-    class DotNet(Grpc):
-        def __init__(self, parent):
-            super().__init__(parent)
-
-        def update_contact_radius(self, radius):
-            self.parent.contact_radius = self._pedb.edb_value(radius).ToDouble()
+    def update_contact_radius(self, radius):
+        self.contact_radius = self._pedb.edb_value(radius).ToDouble()
 
     def __init__(self, pedb, **kwargs):
         self._pedb = pedb
-        if self._pedb.grpc:
-            self.api = self.Grpc(self)
-        else:
-            self.api = self.DotNet(self)
 
         if kwargs.get("padstack"):
             self.type = "padstack"
@@ -76,7 +57,8 @@ class CfgTerminalInfo(CfgBase):
 
         self.contact_type = kwargs.get("contact_type", "default")  # options are full, center, quad, inline
         contact_radius = "0.1mm" if kwargs.get("contact_radius") is None else kwargs.get("contact_radius")
-        self.api.update_contact_radius(contact_radius)
+
+        self.contact_radius = self._pedb.edb_value(contact_radius).ToDouble()
         self.num_of_contact = kwargs.get("num_of_contact", 4)
         self.contact_expansion = kwargs.get("contact_expansion", 1)
 
@@ -108,27 +90,11 @@ class CfgNearestPinTerminalInfo(CfgTerminalInfo):
 
 
 class CfgSources:
-    class Grpc:
-        def __init__(self, parent):
-            self.parent = parent
-            self._pedb = parent._pedb
-
-        def get_pin_group_name(self, src):
-            return src.pin_group.name
-
-    class DotNet(Grpc):
-        def __init__(self, parent):
-            super().__init__(parent)
-
-        def get_pin_group_name(self, src):
-            return src._edb_object.GetPinGroup().GetName()
+    def get_pin_group_name(self, src):
+        return src._edb_object.GetPinGroup().GetName()
 
     def __init__(self, pedb, sources_data):
         self._pedb = pedb
-        if self._pedb.grpc:
-            self.api = self.Grpc(self)
-        else:
-            self.api = self.DotNet(self)
         self.sources = [CfgSource(self._pedb, **src) for src in sources_data]
 
     def apply(self):
@@ -147,7 +113,7 @@ class CfgSources:
 
             if src.terminal_type == "PinGroupTerminal":
                 refdes = ""
-                pg = self._pedb.siwave.pin_groups[self.api.get_pin_group_name(src)]
+                pg = self._pedb.siwave.pin_groups[self.get_pin_group_name(src)]
                 pos_term_info = {"pin_group": pg.name}
             elif src.terminal_type == "PadstackInstanceTerminal":
                 refdes = src.component.refdes if src.component else ""
@@ -155,7 +121,7 @@ class CfgSources:
 
             neg_term = self._pedb.terminals[src.ref_terminal.name]
             if neg_term.terminal_type == "PinGroupTerminal":
-                pg = self._pedb.siwave.pin_groups[self.api.get_pin_group_name(neg_term)]
+                pg = self._pedb.siwave.pin_groups[self.get_pin_group_name(neg_term)]
                 neg_term_info = {"pin_group": pg.name}
             elif neg_term.terminal_type == "PadstackInstanceTerminal":
                 neg_term_info = {"padstack": neg_term.padstack_instance.aedt_name}
@@ -180,68 +146,29 @@ class CfgSources:
 
 
 class CfgPorts:
-    class Grpc:
-        def __init__(self, parent):
-            self.parent = parent
-            self._pedb = parent._pedb
-
-        def get_pin_group(self, port):
-            return self._pedb.siwave.pin_groups[port._edb_object.pin_group.name]
-
-        def get_edge_info(self, port):
-            return port._edb_object.GetEdges()[0].GetParameters()
-
-        def _get_edge_port_from_edb(self, p, port_type):
-            # primitive, point = p._edb_object.GetEdges()[0].GetParameters()
-            edges = p.edges
-            primitive = None
-            point = None
-            primitive = Primitive(self._pedb, primitive)
-            point = PointData(self._pedb, point)
-
-            cfg_port = CfgEdgePort(
-                self._pedb,
-                name=p.name,
-                type=port_type,
-                primitive_name=primitive.aedt_name,
-                point_on_edge=[point._edb_object.X.ToString(), point._edb_object.Y.ToString()],
-                horizontal_extent_factor=p.horizontal_extent_factor,
-                vertical_extent_factor=p.vertical_extent_factor,
-                pec_launch_width=p.pec_launch_width,
-            )
-            return cfg_port
+    def get_pin_group(self, port):
+        return self._pedb.siwave.pin_groups[port._edb_object.GetPinGroup().GetName()]
 
-    class DotNet(Grpc):
-        def __init__(self, parent):
-            super().__init__(parent)
+    def _get_edge_port_from_edb(self, p, port_type):
+        _, primitive, point = p._edb_object.GetEdges()[0].GetParameters()
 
-        def get_pin_group(self, port):
-            return self._pedb.siwave.pin_groups[port._edb_object.GetPinGroup().GetName()]
+        primitive = Primitive(self._pedb, primitive)
+        point = PointData(self._pedb, point)
 
-        def _get_edge_port_from_edb(self, p, port_type):
-            _, primitive, point = p._edb_object.GetEdges()[0].GetParameters()
-
-            primitive = Primitive(self._pedb, primitive)
-            point = PointData(self._pedb, point)
-
-            cfg_port = CfgEdgePort(
-                self._pedb,
-                name=p.name,
-                type=port_type,
-                primitive_name=primitive.aedt_name,
-                point_on_edge=[point._edb_object.X.ToString(), point._edb_object.Y.ToString()],
-                horizontal_extent_factor=p.horizontal_extent_factor,
-                vertical_extent_factor=p.vertical_extent_factor,
-                pec_launch_width=p.pec_launch_width,
-            )
-            return cfg_port
+        cfg_port = CfgEdgePort(
+            self._pedb,
+            name=p.name,
+            type=port_type,
+            primitive_name=primitive.aedt_name,
+            point_on_edge=[point._edb_object.X.ToString(), point._edb_object.Y.ToString()],
+            horizontal_extent_factor=p.horizontal_extent_factor,
+            vertical_extent_factor=p.vertical_extent_factor,
+            pec_launch_width=p.pec_launch_width,
+        )
+        return cfg_port
 
     def __init__(self, pedb, ports_data):
         self._pedb = pedb
-        if self._pedb.grpc:
-            self.api = self.Grpc(self)
-        else:
-            self.api = self.DotNet(self)
         self.ports = []
         for p in ports_data:
             if p["type"] == "wave_port":
@@ -256,18 +183,8 @@ class CfgPorts:
                 raise ValueError("Unknown port type")
 
     def apply(self):
-        edb_primitives = {}
-        for i in self._pedb.layout.primitives:
-            if i.aedt_name:
-                edb_primitives[i.aedt_name] = i
-        for i in self._pedb.layout.padstack_instances:
-            if i.aedt_name:
-                edb_primitives[i.aedt_name] = i
         for p in self.ports:
-            if p.type in ["wave_port", "diff_wave_port", "gap_port"]:
-                p.set_parameters_to_edb(edb_primitives)
-            else:
-                p.set_parameters_to_edb()
+            p.set_parameters_to_edb()
 
     def get_data_from_db(self):
         self.ports = []
@@ -289,7 +206,7 @@ class CfgPorts:
 
             if p.terminal_type == "PinGroupTerminal":
                 refdes = ""
-                pg = self.api.get_pin_group(p)
+                pg = self.get_pin_group(p)
                 pos_term_info = {"pin_group": pg.name}
             elif p.terminal_type == "PadstackInstanceTerminal":
                 refdes = p.component.refdes if p.component else ""
@@ -301,7 +218,7 @@ class CfgPorts:
             if port_type == "circuit":
                 neg_term = self._pedb.terminals[p.ref_terminal.name]
                 if neg_term.terminal_type == "PinGroupTerminal":
-                    pg = self.api.get_pin_group(neg_term)
+                    pg = self.get_pin_group(neg_term)
                     # pg = self._pedb.siwave.pin_groups[neg_term._edb_object.GetPinGroup().GetName()]
                     neg_term_info = {"pin_group": pg.name}
                 elif neg_term.terminal_type == "PadstackInstanceTerminal":
@@ -332,7 +249,7 @@ class CfgPorts:
                     positive_terminal=pos_term_info,
                 )
             else:
-                cfg_port = self.api._get_edge_port_from_edb(p, port_type)
+                cfg_port = self._get_edge_port_from_edb(p, port_type)
             self.ports.append(cfg_port)
         return self.export_properties()
 
@@ -350,7 +267,7 @@ class CfgProbes:
 
     def apply(self):
         for probe in self.probes:
-            probe.api.set_parameters_to_edb()
+            probe.set_parameters_to_edb()
 
 
 class CfgCircuitElement(CfgBase):
@@ -740,134 +657,63 @@ class CfgSource(CfgCircuitElement):
 
 
 class CfgProbe(CfgCircuitElement):
-    class Common:
-        def __init__(self, parent):
-            self.parent = parent
-            self.pedb = parent._pedb
-
-        def set_parameters_to_edb(self):
-            self.parent.create_terminals()
-            circuit_elements = []
-            for name, j in self.parent.pos_terminals.items():
-                if isinstance(self.parent.neg_terminal, dict):
-                    elem = self.pedb.create_voltage_probe(j, self.parent.neg_terminal[name])
-                else:
-                    elem = self.pedb.create_voltage_probe(j, self.parent.neg_terminal)
-                elem.name = self.parent.name
-                circuit_elements.append(elem)
-            return circuit_elements
-
-    class Grpc(Common):
-        def __init__(self, parent):
-            super().__init__(parent)
-
-    class DotNet(Grpc):
-        def __init__(self, parent):
-            super().__init__(parent)
+    def set_parameters_to_edb(self):
+        self.create_terminals()
+        circuit_elements = []
+        for name, j in self.pos_terminals.items():
+            if isinstance(self.neg_terminal, dict):
+                elem = self._pedb.create_voltage_probe(j, self.neg_terminal[name])
+            else:
+                elem = self._pedb.create_voltage_probe(j, self.neg_terminal)
+            elem.name = self.name
+            circuit_elements.append(elem)
+        return circuit_elements
 
     def __init__(self, pedb, **kwargs):
         kwargs["type"] = "probe"
         super().__init__(pedb, **kwargs)
-        if os.environ["PYEDB_USE_DOTNET"] == "0":
-            self.api = self.Grpc(self)
-        else:
-            self.api = self.DotNet(self)
 
 
 class CfgEdgePort:
-    class Grpc:
-        def __init__(self, parent):
-            self.parent = parent
-            self._pedb = parent._pedb
-
-        def set_parameters_to_edb(self, edb_primitives):
-            from ansys.edb.core.geometry.point_data import PointData as GrpcPointData
-            from ansys.edb.core.terminal.edge_terminal import (
-                EdgeTerminal as GrpcEdgeTerminal,
-            )
-            from ansys.edb.core.terminal.edge_terminal import (
-                PrimitiveEdge as GrpcPrimitiveEdge,
-            )
-            from ansys.edb.core.utility.value import Value as GrpcValue
-
-            from pyedb.grpc.database.ports.ports import WavePort
-
-            point_on_edge = GrpcPointData(self.parent.point_on_edge)
-            primitive = edb_primitives[self.parent.primitive_name]
-            pos_edge = GrpcPrimitiveEdge.create(primitive, point_on_edge)
-            edge_term = GrpcEdgeTerminal.create(
-                layout=primitive.layout, name=self.parent.name, net=primitive.net, edges=[pos_edge], is_ref=False
-            )
-            edge_term.impedance = GrpcValue(50)
-            wave_port = WavePort(self._pedb, edge_term)
-            wave_port.horizontal_extent_factor = self.parent.horizontal_extent_factor
-            wave_port.vertical_extent_factor = self.parent.vertical_extent_factor
-            wave_port.pec_launch_width = self.parent.pec_launch_width
-            if self.parent.type == "wave_port":
-                wave_port.hfss_type = "Wave"
-            else:
-                wave_port.hfss_type = "Gap"
-            wave_port.do_renormalize = True
-            return wave_port
-
-        def export_properties(self):
-            return {
-                "name": self.name,
-                "type": self.type,
-                "primitive_name": self.primitive_name,
-                "point_on_edge": self.point_on_edge,
-                "horizontal_extent_factor": self.horizontal_extent_factor,
-                "vertical_extent_factor": self.vertical_extent_factor,
-                "pec_launch_width": self.pec_launch_width,
-            }
-
-    class DotNet(Grpc):
-        def __init__(self, parent):
-            super().__init__(parent)
+    def set_parameters_to_edb(self):
+        point_on_edge = PointData(self._pedb, x=self.point_on_edge[0], y=self.point_on_edge[1])
+        primitive = self._pedb.layout.primitives_by_aedt_name[self.primitive_name]
+        pos_edge = self._pedb.edb_api.cell.terminal.PrimitiveEdge.Create(
+            primitive._edb_object, point_on_edge._edb_object
+        )
+        pos_edge = convert_py_list_to_net_list(pos_edge, self._pedb.edb_api.cell.terminal.Edge)
+        edge_term = self._pedb.edb_api.cell.terminal.EdgeTerminal.Create(
+            primitive._edb_object.GetLayout(),
+            primitive._edb_object.GetNet(),
+            self.name,
+            pos_edge,
+            isRef=False,
+        )
+        edge_term.SetImpedance(self._pedb.edb_value(50))
+        wave_port = WavePort(self._pedb, edge_term)
+        wave_port.horizontal_extent_factor = self.horizontal_extent_factor
+        wave_port.vertical_extent_factor = self.vertical_extent_factor
+        wave_port.pec_launch_width = self.pec_launch_width
+        if self.type == "wave_port":
+            wave_port.hfss_type = "Wave"
+        else:
+            wave_port.hfss_type = "Gap"
+        wave_port.do_renormalize = True
+        return wave_port
 
-        def set_parameters_to_edb(self, edb_primitives):
-            point_on_edge = PointData(self._pedb, x=self.parent.point_on_edge[0], y=self.parent.point_on_edge[1])
-            primitive = edb_primitives[self.parent.primitive_name]
-            pos_edge = self._pedb.edb_api.cell.terminal.PrimitiveEdge.Create(
-                primitive._edb_object, point_on_edge._edb_object
-            )
-            pos_edge = convert_py_list_to_net_list(pos_edge, self._pedb.edb_api.cell.terminal.Edge)
-            edge_term = self._pedb.edb_api.cell.terminal.EdgeTerminal.Create(
-                primitive._edb_object.GetLayout(),
-                primitive._edb_object.GetNet(),
-                self.parent.name,
-                pos_edge,
-                isRef=False,
-            )
-            edge_term.SetImpedance(self._pedb.edb_value(50))
-            wave_port = WavePort(self._pedb, edge_term)
-            wave_port.horizontal_extent_factor = self.parent.horizontal_extent_factor
-            wave_port.vertical_extent_factor = self.parent.vertical_extent_factor
-            wave_port.pec_launch_width = self.parent.pec_launch_width
-            if self.parent.type == "wave_port":
-                wave_port.hfss_type = "Wave"
-            else:
-                wave_port.hfss_type = "Gap"
-            wave_port.do_renormalize = True
-            return wave_port
-
-        def export_properties(self):
-            return {
-                "name": self.parent.name,
-                "type": self.parent.type,
-                "primitive_name": self.parent.primitive_name,
-                "point_on_edge": self.parent.point_on_edge,
-                "horizontal_extent_factor": self.parent.horizontal_extent_factor,
-                "vertical_extent_factor": self.parent.vertical_extent_factor,
-                "pec_launch_width": self.parent.pec_launch_width,
-            }
+    def export_properties(self):
+        return {
+            "name": self.name,
+            "type": self.type,
+            "primitive_name": self.primitive_name,
+            "point_on_edge": self.point_on_edge,
+            "horizontal_extent_factor": self.horizontal_extent_factor,
+            "vertical_extent_factor": self.vertical_extent_factor,
+            "pec_launch_width": self.pec_launch_width,
+        }
 
     def __init__(self, pedb, **kwargs):
         self._pedb = pedb
-        if self._pedb.grpc:
-            self.api = self.Grpc(self)
-        else:
-            self.api = self.DotNet(self)
         self.name = kwargs["name"]
         self.type = kwargs["type"]
         self.primitive_name = kwargs["primitive_name"]
@@ -876,12 +722,6 @@ class CfgEdgePort:
         self.vertical_extent_factor = kwargs.get("vertical_extent_factor", 3)
         self.pec_launch_width = kwargs.get("pec_launch_width", "0.01mm")
 
-    def set_parameters_to_edb(self, edb_primitives):
-        return self.api.set_parameters_to_edb(edb_primitives)
-
-    def export_properties(self):
-        return self.api.export_properties()
-
 
 class CfgDiffWavePort:
     def __init__(self, pedb, **kwargs):
@@ -911,9 +751,9 @@ class CfgDiffWavePort:
             **kwargs["negative_terminal"],
         )
 
-    def set_parameters_to_edb(self, edb_primitives):
-        pos_term = self.positive_port.set_parameters_to_edb(edb_primitives)
-        neg_term = self.negative_port.set_parameters_to_edb(edb_primitives)
+    def set_parameters_to_edb(self):
+        pos_term = self.positive_port.set_parameters_to_edb()
+        neg_term = self.negative_port.set_parameters_to_edb()
         edb_list = convert_py_list_to_net_list(
             [pos_term._edb_object, neg_term._edb_object], self._pedb.edb_api.cell.terminal.Terminal
         )

pyedb/configuration/configuration.py

@@ -20,6 +20,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+from datetime import datetime
 import json
 import os
 from pathlib import Path
@@ -446,50 +447,76 @@ class Configuration:
             self.cfg_data.general.apply()
 
         # Configure boundary settings
+        now = datetime.now()
         if self.cfg_data.boundaries:
             self.cfg_data.boundaries.apply()
+        self._pedb.logger.info(f"Updating boundaries finished. Time lapse {datetime.now() - now}")
+        now = datetime.now()
 
         # Configure nets
         if self.cfg_data.nets:
             self.cfg_data.nets.apply()
+        self._pedb.logger.info(f"Updating nets finished. Time lapse {datetime.now() - now}")
+        now = datetime.now()
 
         # Configure components
         self.cfg_data.components.apply()
+        self._pedb.logger.info(f"Updating components finished. Time lapse {datetime.now() - now}")
+        now = datetime.now()
 
         # Configure pin groups
         self.cfg_data.pin_groups.apply()
+        self._pedb.logger.info(f"Creating pin groups finished. Time lapse {datetime.now() - now}")
+        now = datetime.now()
 
         # Configure sources
         self.cfg_data.sources.apply()
+        self._pedb.logger.info(f"Placing sources finished. Time lapse {datetime.now() - now}")
+        now = datetime.now()
 
         # Configure setup
         self.cfg_data.setups.apply()
+        self._pedb.logger.info(f"Creating setups finished. Time lapse {datetime.now() - now}")
+        now = datetime.now()
 
         # Configure stackup
         self.api.configuration_stackup(kwargs)
+        self._pedb.logger.info(f"Updating stackup finished. Time lapse {datetime.now() - now}")
+        now = datetime.now()
 
         # Configure padstacks
         if self.cfg_data.padstacks:
             self.cfg_data.padstacks.apply()
+        self._pedb.logger.info(f"Applying padstacks finished. Time lapse {datetime.now() - now}")
+        now = datetime.now()
 
         # Configure S-parameter
         self.cfg_data.s_parameters.apply()
+        self._pedb.logger.info(f"Applying S-parameters finished. Time lapse {datetime.now() - now}")
+        now = datetime.now()
 
         # Configure SPICE models
         for spice_model in self.cfg_data.spice_models:
             spice_model.apply()
+        self._pedb.logger.info(f"Assigning Spice models finished. Time lapse {datetime.now() - now}")
+        now = datetime.now()
 
         # Configure package definitions
         self.cfg_data.package_definitions.apply()
+        self._pedb.logger.info(f"Applying package definitions finished. Time lapse {datetime.now() - now}")
+        now = datetime.now()
 
         # Modeler
         self.cfg_data.modeler.apply()
 
         # Configure ports
         self.cfg_data.ports.apply()
+        self._pedb.logger.info(f"Placing ports finished. Time lapse {datetime.now() - now}")
+        now = datetime.now()
 
         # Configure probes
         self.cfg_data.probes.apply()
+        self._pedb.logger.info(f"Placing probes finished. Time lapse {datetime.now() - now}")
 
         # Configure operations
         self.cfg_data.operations.apply()

pyedb/dotnet/clr_module.py

@@ -38,6 +38,7 @@ if is_linux:  # pragma: no cover
 
     dotnet_root = None
     runtime_config = None
+    runtime_spec = None
     # Use system .NET core runtime or fall back to dotnetcore2
     if os.environ.get("DOTNET_ROOT") is None:
         try:
@@ -78,11 +79,16 @@ if is_linux:  # pragma: no cover
                     "Please ensure that .NET SDK is correctly installed or "
                     "that DOTNET_ROOT is correctly set."
                 )
-            runtime_config = candidates[0]
+            runtime_spec = candidates[0]
     # Use specific .NET core runtime
-    if dotnet_root is not None and runtime_config is not None:
+    if dotnet_root is not None and (runtime_config is not None or runtime_spec is not None):
         try:
-            load("coreclr", runtime_config=str(runtime_config), dotnet_root=str(dotnet_root))
+            load(
+                "coreclr",
+                runtime_config=str(runtime_config) if runtime_config else None,
+                runtime_spec=runtime_spec,
+                dotnet_root=str(dotnet_root),
+            )
             os.environ["DOTNET_ROOT"] = dotnet_root.as_posix()
             if "mono" not in os.getenv("LD_LIBRARY_PATH", ""):
                 warnings.warn("LD_LIBRARY_PATH needs to be setup to use pyedb.")

pyedb/dotnet/database/cell/layout.py

@@ -80,6 +80,7 @@ def primitive_cast(pedb, edb_object):
 class Layout(ObjBase):
     def __init__(self, pedb, edb_object):
         super().__init__(pedb, edb_object)
+        self._primitives = []
 
     @property
     def cell(self):
@@ -230,7 +231,15 @@ class Layout(ObjBase):
         -------
         list of :class:`dotnet.database.dotnet.primitive.PrimitiveDotNet` cast objects.
         """
-        return [primitive_cast(self._pedb, p) for p in self._edb_object.Primitives if p]
+        primitives = list(self._edb_object.Primitives)
+        if len(primitives) != len(self._primitives):
+            self._primitives = [primitive_cast(self._pedb, p) for p in primitives]
+        return self._primitives
+
+    @property
+    def primitives_by_aedt_name(self) -> dict:
+        """Primitives."""
+        return {i.aedt_name: i for i in self.primitives}
 
     @property
     def bondwires(self):

pyedb/dotnet/database/dotnet/database.py

@@ -27,7 +27,6 @@ import sys
 
 from pyedb import __version__
 from pyedb.dotnet.database.general import convert_py_list_to_net_list
-from pyedb.edb_logger import pyedb_logger
 from pyedb.generic.general_methods import (
     env_path,
     env_path_student,
@@ -704,7 +703,6 @@ class EdbDotNet(object):
     """Edb Dot Net Class."""
 
     def __init__(self, edbversion, student_version=False):
-        self._logger = pyedb_logger
         if not edbversion:  # pragma: no cover
             try:
                 edbversion = "20{}.{}".format(list_installed_ansysem()[0][-3:-1], list_installed_ansysem()[0][-1:])

pyedb/dotnet/database/layout_validation.py

@@ -304,20 +304,24 @@ class LayoutValidation:
 
     def illegal_rlc_values(self, fix=False):
         """Find and fix RLC illegal values."""
-        inductors = self._pedb.components.inductors
 
-        temp = []
-        for k, v in inductors.items():
-            componentProperty = v.edbcomponent.GetComponentProperty()
-            model = componentProperty.GetModel().Clone()
-            pinpairs = model.PinPairs
-
-            if not len(list(pinpairs)):  # pragma: no cover
-                temp.append(k)
-                if fix:
-                    v.rlc_values = [0, 1, 0]
-
-        self._pedb._logger.info("Found {} inductors have no value.".format(len(temp)))
+        for name, objs in {
+            "inductors": self._pedb.components.inductors,
+            "resistors": self._pedb.components.resistors,
+            "capacitors": self._pedb.components.capacitors,
+        }.items():
+            temp = []
+            for k, v in objs.items():
+                componentProperty = v.edbcomponent.GetComponentProperty()
+                model = componentProperty.GetModel().Clone()
+                pinpairs = model.PinPairs
+
+                if not len(list(pinpairs)):  # pragma: no cover
+                    temp.append(k)
+                    if fix:
+                        v.rlc_values = [0, 1, 0]
+
+            self._pedb._logger.info(f"Found {len(temp)} {name} have no value.")
         return
 
     def padstacks_no_name(self, fix=False):

pyedb/dotnet/database/modeler.py

@@ -67,7 +67,6 @@ class Modeler(object):
 
     def __init__(self, p_edb):
         self._pedb = p_edb
-        self._primitives = []
 
     @property
     def _edb(self):