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

pyedb/configuration/cfg_pin_groups.py

@@ -26,64 +26,34 @@ from pyedb.configuration.cfg_common import CfgBase
 class CfgPinGroups:
     """Manage configuration pin group class."""
 
-    class Grpc:
-        def __init__(self, parent):
-            self.parent = parent
-            self._pedb = parent._pedb
-
-        def set_pingroup_to_edb(self):
-            for pg in self.parent.pin_groups:
-                pg.create()
-
-        def get_data_from_edb(self):
-            self.parent.pin_groups = []
-            layout_pin_groups = self._pedb.siwave.pin_groups
-            for pg_name, pg_obj in layout_pin_groups.items():
-                if self._pedb.grpc:
-                    pins = list(pg_obj.pins.values())
-                    refdes = pins[0].component.name
-                    cfg_pg = CfgPinGroup(
-                        self._pedb,
-                        name=pg_name,
-                        reference_designator=refdes,
-                        pins=[pin.component_pin for pin in pins],
-                    )
-                    self.parent.pin_groups.append(cfg_pg)
-            return self.parent.export_properties()
-
-    class DotNet(Grpc):
-        def __init__(self, parent):
-            self.parent = parent
-            super().__init__(parent)
-
-        def get_data_from_edb(self):
-            self.parent.pin_groups = []
-            layout_pin_groups = self._pedb.siwave.pin_groups
-            for pg_name, pg_obj in layout_pin_groups.items():
-                pins = list(pg_obj.pins.keys())
-                refdes = list(pg_obj.pins.values())[0].component.name
-                cfg_pg = CfgPinGroup(
-                    self._pedb,
-                    name=pg_name,
-                    reference_designator=refdes,
-                    pins=pins,
-                )
-                self.parent.pin_groups.append(cfg_pg)
-            return self.parent.export_properties()
+    def set_pingroup_to_edb(self):
+        for pg in self.pin_groups:
+            pg.create()
+
+    def get_data_from_edb(self):
+        self.pin_groups = []
+        layout_pin_groups = self._pedb.siwave.pin_groups
+        for pg_name, pg_obj in layout_pin_groups.items():
+            pins = list(pg_obj.pins.keys())
+            refdes = list(pg_obj.pins.values())[0].component.name
+            cfg_pg = CfgPinGroup(
+                self._pedb,
+                name=pg_name,
+                reference_designator=refdes,
+                pins=pins,
+            )
+            self.pin_groups.append(cfg_pg)
+        return self.export_properties()
 
     def __init__(self, pedb, pingroup_data):
         self._pedb = pedb
-        if self._pedb.grpc:
-            self.api = self.Grpc(self)
-        else:
-            self.api = self.DotNet(self)
         self.pin_groups = [CfgPinGroup(self._pedb, **pg) for pg in pingroup_data]
 
     def apply(self):
-        self.api.set_pingroup_to_edb()
+        self.set_pingroup_to_edb()
 
     def get_data_from_db(self):
-        return self.api.get_data_from_edb()
+        return self.get_data_from_edb()
 
     def export_properties(self):
         pin_groups = []
@@ -93,43 +63,26 @@ class CfgPinGroups:
 
 
 class CfgPinGroup(CfgBase):
-    class Grpc:
-        def __init__(self, parent):
-            self.parent = parent
-            self._pedb = parent._pedb
-
-        def create(self):
-            if self.parent.pins:
-                pins = self.parent.pins if isinstance(self.parent.pins, list) else [self.parent.pins]
-                self._pedb.siwave.create_pin_group(self.parent.reference_designator, pins, self.parent.name)
-            elif self.parent.net:
-                nets = self.parent.net if isinstance(self.parent.net, list) else [self.parent.net]
-                comp = self._pedb.components.instances[self.parent.reference_designator]
-                pins = [p for p, obj in comp.pins.items() if obj.net_name in nets]
-                if not self._pedb.siwave.create_pin_group(self.parent.reference_designator, pins, self.parent.name):
-                    raise RuntimeError(f"Failed to create pin group {self.parent.name}")
-            else:
-                raise RuntimeError(f"No net and pins defined for defining pin group {self.parent.name}")
-
-    class DotNet(Grpc):
-        def __init__(self, parent):
-            super().__init__(parent)
+    def create(self):
+        if self.pins:
+            pins = self.pins if isinstance(self.pins, list) else [self.pins]
+            self._pedb.siwave.create_pin_group(self.reference_designator, pins, self.name)
+        elif self.net:
+            nets = self.net if isinstance(self.net, list) else [self.net]
+            comp = self._pedb.components.instances[self.reference_designator]
+            pins = [p for p, obj in comp.pins.items() if obj.net_name in nets]
+            if not self._pedb.siwave.create_pin_group(self.reference_designator, pins, self.name):
+                raise RuntimeError(f"Failed to create pin group {self.name}")
+        else:
+            raise RuntimeError(f"No net and pins defined for defining pin group {self.name}")
 
     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.reference_designator = kwargs.get("reference_designator")
         self.pins = kwargs.get("pins")
         self.net = kwargs.get("net")
 
-    def create(self):
-        """Apply pin group on layout."""
-        self.api.create()
-
     def export_properties(self):
         if self.pins:
             return {

pyedb/configuration/cfg_ports_sources.py

@@ -130,6 +130,7 @@ class CfgSources:
                 self._pedb,
                 name=name,
                 type=src_type,
+                impedance=src.impedance,
                 magnitude=magnitude,
                 reference_designator=refdes,
                 positive_terminal=pos_term_info,
@@ -236,6 +237,7 @@ class CfgPorts:
                     self._pedb,
                     name=p.name,
                     type=port_type,
+                    impedance=p.impedance,
                     reference_designator=refdes,
                     positive_terminal=pos_term_info,
                     negative_terminal=neg_term_info,
@@ -245,6 +247,7 @@ class CfgPorts:
                     self._pedb,
                     name=p.name,
                     type=port_type,
+                    impedance=p.impedance,
                     reference_designator=refdes,
                     positive_terminal=pos_term_info,
                 )
@@ -275,6 +278,7 @@ class CfgCircuitElement(CfgBase):
         self._pedb = pedb
         self.name = kwargs["name"]
         self.type = kwargs["type"]
+        self.impedance = kwargs.get("impedance", None)
         self.reference_designator = kwargs.get("reference_designator", None)
         self.distributed = kwargs.get("distributed", False)
         self._elem_num = 1
@@ -558,6 +562,7 @@ class CfgPort(CfgCircuitElement):
                 elem = self._pedb.create_port(j, self.neg_terminal[name], is_circuit_port)
             else:
                 elem = self._pedb.create_port(j, self.neg_terminal, is_circuit_port)
+            elem.impedance = self.impedance if self.impedance else self._pedb.edb_value(50)
             if not self.distributed:
                 elem.name = self.name
             circuit_elements.append(elem)
@@ -567,6 +572,7 @@ class CfgPort(CfgCircuitElement):
         data = {
             "name": self.name,
             "type": self.type,
+            "impedance": self.impedance,
             "reference_designator": self.reference_designator,
             "positive_terminal": self.positive_terminal_info.export_properties(),
         }
@@ -596,6 +602,12 @@ class CfgSource(CfgCircuitElement):
                 elem = create_xxx_source(j, self.neg_terminal[name])
             else:
                 elem = create_xxx_source(j, self.neg_terminal)
+
+            if self.impedance:
+                elem.impedance = self.impedance
+            else:
+                elem.impedance = 5e7 if self.type == "current" else 1e-6
+
             if self._elem_num == 1:
                 elem.name = self.name
                 elem.magnitude = self.magnitude
@@ -650,6 +662,7 @@ class CfgSource(CfgCircuitElement):
             "name": self.name,
             "reference_designator": self.reference_designator,
             "type": self.type,
+            "impedance": self.impedance,
             "magnitude": self.magnitude,
             "positive_terminal": self.positive_terminal_info.export_properties(),
             "negative_terminal": self.negative_terminal_info.export_properties(),
@@ -676,11 +689,11 @@ class CfgProbe(CfgCircuitElement):
 
 class CfgEdgePort:
     def set_parameters_to_edb(self):
-        point_on_edge = PointData(self._pedb, x=self.point_on_edge[0], y=self.point_on_edge[1])
+        point_on_edge = PointData.create_from_xy(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.core.cell.terminal.PrimitiveEdge.Create(primitive._edb_object, point_on_edge._edb_object)
-        pos_edge = convert_py_list_to_net_list(pos_edge, self._pedb.core.cell.terminal.Edge)
-        edge_term = self._pedb.core.cell.terminal.EdgeTerminal.Create(
+        pos_edge = self._pedb.core.Cell.Terminal.PrimitiveEdge.Create(primitive._edb_object, point_on_edge._edb_object)
+        pos_edge = convert_py_list_to_net_list(pos_edge, self._pedb.core.Cell.Terminal.Edge)
+        edge_term = self._pedb.core.Cell.Terminal.EdgeTerminal.Create(
             primitive._edb_object.GetLayout(),
             primitive._edb_object.GetNet(),
             self.name,
@@ -753,9 +766,9 @@ class CfgDiffWavePort:
         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.core.cell.terminal.Terminal
+            [pos_term._edb_object, neg_term._edb_object], self._pedb.core.Cell.Terminal.Terminal
         )
-        _edb_boundle_terminal = self._pedb.core.cell.terminal.BundleTerminal.Create(edb_list)
+        _edb_boundle_terminal = self._pedb.core.Cell.Terminal.BundleTerminal.Create(edb_list)
         _edb_boundle_terminal.SetName(self.name)
         pos, neg = list(_edb_boundle_terminal.GetTerminals())
         pos.SetName(self.name + ":T1")

pyedb/configuration/cfg_s_parameter_models.py

@@ -36,186 +36,81 @@ class CfgSParameterModel:
 
 
 class CfgSParameters:
-    class Grpc:
-        def __init__(self, parent):
-            self.parent = parent
-            self._pedb = parent._pedb
-
-        def apply(self):
-            for s_param in self.parent.s_parameters_models:
-                fpath = s_param.file_path
-                if not Path(fpath).anchor:
-                    fpath = str(Path(self.parent.path_libraries) / fpath)
-                comp_def = self._pedb.definitions.component[s_param.component_definition]
-                if s_param.pin_order:
-                    comp_def.set_properties(pin_order=s_param.pin_order)
-                comp_def.add_n_port_model(fpath, s_param.name)
-                comp_list = dict()
-                if s_param.apply_to_all:
-                    comp_list.update(
-                        {
-                            refdes: comp
-                            for refdes, comp in comp_def.components.items()
-                            if refdes not in s_param.components
-                        }
-                    )
-                else:
-                    comp_list.update(
-                        {refdes: comp for refdes, comp in comp_def.components.items() if refdes in s_param.components}
-                    )
-
-                for refdes, comp in comp_list.items():
-                    if refdes in s_param.reference_net_per_component:
-                        ref_net = s_param.reference_net_per_component[refdes]
-                    else:
-                        ref_net = s_param.reference_net
-                    comp.use_s_parameter_model(s_param.name, reference_net=ref_net)
-
-        def get_data_from_db(self, cfg_components):
-            db_comp_def = self._pedb.definitions.component
-            for name, compdef_obj in db_comp_def.items():
-                nport_models = compdef_obj.component_models
-                if not nport_models:
-                    continue
-                else:
-                    pin_order = compdef_obj.get_properties()["pin_order"]
-                    temp_comps = [i for i in cfg_components if i["definition"] == name]
-                    for model_obj in nport_models:
-                        temp_comp_list = []
-                        reference_net_per_component = {}
-                        for i in temp_comps:
-                            s_param_model = i.get("s_parameter_model")
-                            if s_param_model:
-                                if s_param_model["model_name"] == model_name:
-                                    temp_comp_list.append(i["reference_designator"])
-                                    reference_net_per_component[i["reference_designator"]] = s_param_model[
-                                        "reference_net"
-                                    ]
-                            else:
-                                continue
-
-                        self.parent.s_parameters_models.append(
-                            CfgSParameterModel(
-                                name=model_name,
-                                component_definition=name,
-                                file_path=model_obj.reference_file,
-                                apply_to_all=False,
-                                components=temp_comp_list,
-                                reference_net_per_component=reference_net_per_component,
-                                pin_order=pin_order,
-                            )
-                        )
-
-            data = []
-            for i in self.parent.s_parameters_models:
-                data.append(
-                    {
-                        "name": i.name,
-                        "component_definition": i.component_definition,
-                        "file_path": i.file_path,
-                        "apply_to_all": i.apply_to_all,
-                        "components": i.components,
-                        "reference_net_per_component": i.reference_net_per_component,
-                        "pin_order": i.pin_order,
-                    }
+    def apply(self):
+        for s_param in self.s_parameters_models:
+            fpath = s_param.file_path
+            if not Path(fpath).anchor:
+                fpath = str(Path(self.path_libraries) / fpath)
+            comp_def = self._pedb.definitions.component[s_param.component_definition]
+            if s_param.pin_order:
+                comp_def.set_properties(pin_order=s_param.pin_order)
+            comp_def.add_n_port_model(fpath, s_param.name)
+            comp_list = dict()
+            if s_param.apply_to_all:
+                comp_list.update(
+                    {refdes: comp for refdes, comp in comp_def.components.items() if refdes not in s_param.components}
+                )
+            else:
+                comp_list.update(
+                    {refdes: comp for refdes, comp in comp_def.components.items() if refdes in s_param.components}
                 )
-            return data
-
-    class DotNet(Grpc):
-        def __init__(self, parent):
-            super().__init__(parent)
-
-        def apply(self):
-            for s_param in self.parent.s_parameters_models:
-                fpath = s_param.file_path
-                if not Path(fpath).anchor:
-                    fpath = str(Path(self.parent.path_libraries) / fpath)
-                comp_def = self._pedb.definitions.component[s_param.component_definition]
-                if s_param.pin_order:
-                    comp_def.set_properties(pin_order=s_param.pin_order)
-                comp_def.add_n_port_model(fpath, s_param.name)
-                comp_list = dict()
-                if s_param.apply_to_all:
-                    comp_list.update(
-                        {
-                            refdes: comp
-                            for refdes, comp in comp_def.components.items()
-                            if refdes not in s_param.components
-                        }
-                    )
-                else:
-                    comp_list.update(
-                        {refdes: comp for refdes, comp in comp_def.components.items() if refdes in s_param.components}
-                    )
-
-                for refdes, comp in comp_list.items():
-                    if refdes in s_param.reference_net_per_component:
-                        ref_net = s_param.reference_net_per_component[refdes]
-                    else:
-                        ref_net = s_param.reference_net
-                    comp.use_s_parameter_model(s_param.name, reference_net=ref_net)
 
-        def get_data_from_db(self, cfg_components):
-            db_comp_def = self._pedb.definitions.component
-            for name, compdef_obj in db_comp_def.items():
-                nport_models = compdef_obj.component_models
-                if not nport_models:
-                    continue
+            for refdes, comp in comp_list.items():
+                if refdes in s_param.reference_net_per_component:
+                    ref_net = s_param.reference_net_per_component[refdes]
                 else:
-                    pin_order = compdef_obj.get_properties()["pin_order"]
-                    temp_comps = [i for i in cfg_components if i["definition"] == name]
-                    for model_name, model_obj in nport_models.items():
-                        temp_comp_list = []
-                        reference_net_per_component = {}
-                        for i in temp_comps:
-                            s_param_model = i.get("s_parameter_model")
-                            if s_param_model:
-                                if s_param_model["model_name"] == model_name:
-                                    temp_comp_list.append(i["reference_designator"])
-                                    reference_net_per_component[i["reference_designator"]] = s_param_model[
-                                        "reference_net"
-                                    ]
-                            else:
-                                continue
+                    ref_net = s_param.reference_net
+                comp.use_s_parameter_model(s_param.name, reference_net=ref_net)
 
-                        self.parent.s_parameters_models.append(
-                            CfgSParameterModel(
-                                name=model_name,
-                                component_definition=name,
-                                file_path=model_obj.reference_file,
-                                apply_to_all=False,
-                                components=temp_comp_list,
-                                reference_net_per_component=reference_net_per_component,
-                                pin_order=pin_order,
-                            )
+    def get_data_from_db(self, cfg_components):
+        db_comp_def = self._pedb.definitions.component
+        for name, compdef_obj in db_comp_def.items():
+            nport_models = compdef_obj.component_models
+            if not nport_models:
+                continue
+            else:
+                pin_order = compdef_obj.get_properties()["pin_order"]
+                temp_comps = [i for i in cfg_components if i["definition"] == name]
+                for model_name, model_obj in nport_models.items():
+                    temp_comp_list = []
+                    reference_net_per_component = {}
+                    for i in temp_comps:
+                        s_param_model = i.get("s_parameter_model")
+                        if s_param_model:
+                            if s_param_model["model_name"] == model_name:
+                                temp_comp_list.append(i["reference_designator"])
+                                reference_net_per_component[i["reference_designator"]] = s_param_model["reference_net"]
+                        else:
+                            continue
+
+                    self.s_parameters_models.append(
+                        CfgSParameterModel(
+                            name=model_name,
+                            component_definition=name,
+                            file_path=model_obj.reference_file,
+                            apply_to_all=False,
+                            components=temp_comp_list,
+                            reference_net_per_component=reference_net_per_component,
+                            pin_order=pin_order,
                         )
+                    )
 
-            data = []
-            for i in self.parent.s_parameters_models:
-                data.append(
-                    {
-                        "name": i.name,
-                        "component_definition": i.component_definition,
-                        "file_path": i.file_path,
-                        "apply_to_all": i.apply_to_all,
-                        "components": i.components,
-                        "reference_net_per_component": i.reference_net_per_component,
-                        "pin_order": i.pin_order,
-                    }
-                )
-            return data
+        data = []
+        for i in self.s_parameters_models:
+            data.append(
+                {
+                    "name": i.name,
+                    "component_definition": i.component_definition,
+                    "file_path": i.file_path,
+                    "apply_to_all": i.apply_to_all,
+                    "components": i.components,
+                    "reference_net_per_component": i.reference_net_per_component,
+                    "pin_order": i.pin_order,
+                }
+            )
+        return data
 
     def __init__(self, pedb, data, path_lib=None):
         self._pedb = pedb
-        if self._pedb.grpc:
-            self.api = self.Grpc(self)
-        else:
-            self.api = self.DotNet(self)
         self.path_libraries = path_lib
         self.s_parameters_models = [CfgSParameterModel(**i) for i in data]
-
-    def apply(self):
-        self.api.apply()
-
-    def get_data_from_db(self, cfg_components):
-        return self.api.get_data_from_db(cfg_components)