pyedb 0.42.0__py3-none-any.whl → 0.44.0__py3-none-any.whl

pyedb/configuration/cfg_pin_groups.py

@@ -26,28 +26,40 @@ from pyedb.configuration.cfg_common import CfgBase
 class CfgPinGroups:
     """Manage configuration pin group class."""
 
-    def __init__(self, pedb, pingroup_data):
-        self._pedb = pedb
-        self.pin_groups = [CfgPinGroup(self._pedb, **pg) for pg in pingroup_data]
+    class Grpc:
+        def __init__(self, parent):
+            self.parent = parent
+            self._pedb = parent._pedb
 
-    def apply(self):
-        for pg in self.pin_groups:
-            pg.create()
+        def set_pingroup_to_edb(self):
+            for pg in self.parent.pin_groups:
+                pg.create()
 
-    def get_data_from_db(self):
-        self.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 = pg_obj.pins
-                refdes = pins[0].component.name
-                cfg_pg = CfgPinGroup(
-                    self._pedb,
-                    name=pg_name,
-                    reference_designator=refdes,
-                    pins=[pin.component_pin for pin in pins],
-                )
-            else:
+        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 = pg_obj.pins
+                    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(
@@ -56,8 +68,22 @@ class CfgPinGroups:
                     reference_designator=refdes,
                     pins=pins,
                 )
-            self.pin_groups.append(cfg_pg)
-        return self.export_properties()
+                self.parent.pin_groups.append(cfg_pg)
+            return self.parent.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()
+
+    def get_data_from_db(self):
+        return self.api.get_data_from_edb()
 
     def export_properties(self):
         pin_groups = []
@@ -67,8 +93,34 @@ 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 __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")
@@ -76,17 +128,7 @@ class CfgPinGroup(CfgBase):
 
     def create(self):
         """Apply pin group on layout."""
-        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}")
+        self.api.create()
 
     def export_properties(self):
         if self.pins:

pyedb/configuration/cfg_ports_sources.py

@@ -33,9 +33,33 @@ 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 __init__(self, pedb, **kwargs):
         self._pedb = pedb
-        if "pin" in kwargs:
+        if self._pedb.grpc:
+            self.api = self.Grpc(self)
+        else:
+            self.api = self.DotNet(self)
+
+        if kwargs.get("padstack"):
+            self.type = "padstack"
+        elif "pin" in kwargs:
             self.type = "pin"
         elif "net" in kwargs:
             self.type = "net"
@@ -52,7 +76,7 @@ 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.contact_radius = self._pedb.edb_value(contact_radius).ToDouble()
+        self.api.update_contact_radius(contact_radius)
         self.num_of_contact = kwargs.get("num_of_contact", 4)
         self.contact_expansion = kwargs.get("contact_expansion", 1)
 
@@ -60,7 +84,7 @@ class CfgTerminalInfo(CfgBase):
         return {self.type: self.value}
 
 
-class CfgCoordianteTerminalInfo(CfgTerminalInfo):
+class CfgCoordinateTerminalInfo(CfgTerminalInfo):
     def __init__(self, pedb, **kwargs):
         super().__init__(pedb, **kwargs)
 
@@ -108,14 +132,14 @@ class CfgSources:
                 pos_term_info = {"pin_group": pg.name}
             elif src.terminal_type == "PadstackInstanceTerminal":
                 refdes = src.component.refdes if src.component else ""
-                pos_term_info = {"pin": src.padstack_instance.component_pin}
+                pos_term_info = {"padstack": src.padstack_instance.aedt_name}
 
             neg_term = self._pedb.terminals[src.ref_terminal.name]
             if neg_term.terminal_type == "PinGroupTerminal":
                 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":
-                neg_term_info = {"pin": neg_term.padstack_instance.component_pin}
+                neg_term_info = {"padstack": neg_term.padstack_instance.aedt_name}
 
             cfg_src = CfgSource(
                 self._pedb,
@@ -137,9 +161,30 @@ 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()
+
+    class DotNet(Grpc):
+        def __init__(self, parent):
+            super().__init__(parent)
+
+        def get_pin_group(self, port):
+            return self._pedb.siwave.pin_groups[port._edb_object.GetPinGroup().GetName()]
+
     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":
@@ -156,6 +201,9 @@ class CfgPorts:
         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"]:
                 p.set_parameters_to_edb(edb_primitives)
@@ -171,6 +219,8 @@ class CfgPorts:
             if not p.ref_terminal:
                 if p.terminal_type == "PadstackInstanceTerminal":
                     port_type = "coax"
+                elif p.terminal_type == "PinGroupTerminal":
+                    port_type = "circuit"
                 elif p.hfss_type == "Wave":
                     port_type = "wave_port"
                 else:
@@ -180,11 +230,11 @@ class CfgPorts:
 
             if p.terminal_type == "PinGroupTerminal":
                 refdes = ""
-                pg = self._pedb.siwave.pin_groups[p._edb_object.GetPinGroup().GetName()]
+                pg = self.api.get_pin_group(p)
                 pos_term_info = {"pin_group": pg.name}
             elif p.terminal_type == "PadstackInstanceTerminal":
                 refdes = p.component.refdes if p.component else ""
-                pos_term_info = {"pin": p.padstack_instance.component_pin}
+                pos_term_info = {"padstack": p.padstack_instance.aedt_name}
             elif p.terminal_type == "PointTerminal":
                 refdes = ""
                 pos_term_info = {"coordinates": {"layer": p.layer.name, "point": p.location, "net": p.net.name}}
@@ -192,10 +242,11 @@ class CfgPorts:
             if port_type == "circuit":
                 neg_term = self._pedb.terminals[p.ref_terminal.name]
                 if neg_term.terminal_type == "PinGroupTerminal":
-                    pg = self._pedb.siwave.pin_groups[neg_term._edb_object.GetPinGroup().GetName()]
+                    pg = self.api.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":
-                    neg_term_info = {"pin": neg_term.padstack_instance.component_pin}
+                    neg_term_info = {"padstack": neg_term.padstack_instance.aedt_name}
                 elif neg_term.terminal_type == "PointTerminal":
                     neg_term_info = {
                         "coordinates": {
@@ -269,7 +320,7 @@ class CfgCircuitElement(CfgBase):
 
         pos = kwargs["positive_terminal"]  # {"pin" : "A1"}
         if list(pos.keys())[0] == "coordinates":
-            self.positive_terminal_info = CfgCoordianteTerminalInfo(self._pedb, **pos)
+            self.positive_terminal_info = CfgCoordinateTerminalInfo(self._pedb, **pos)
         else:
             self.positive_terminal_info = CfgTerminalInfo(self._pedb, **pos)
             if not self.positive_terminal_info.reference_designator:
@@ -279,7 +330,7 @@ class CfgCircuitElement(CfgBase):
         if len(neg) == 0:
             self.negative_terminal_info = None
         elif list(neg.keys())[0] == "coordinates":
-            self.negative_terminal_info = CfgCoordianteTerminalInfo(self._pedb, **neg)
+            self.negative_terminal_info = CfgCoordinateTerminalInfo(self._pedb, **neg)
         elif list(neg.keys())[0] == "nearest_pin":
             self.negative_terminal_info = CfgNearestPinTerminalInfo(self._pedb, **neg)
         else:
@@ -306,6 +357,11 @@ class CfgCircuitElement(CfgBase):
                 self._pedb.nets.find_or_create_net(net_name)
             pos_coor_terminal[self.name] = self._pedb.get_point_terminal(self.name, net_name, point, layer)
 
+        elif pos_type == "padstack":
+            for pds in self._pedb.layout.padstack_instances:
+                if pds.aedt_name == pos_value:
+                    pos_objs.update({pos_value: pds})
+                    break
         elif pos_type == "pin":
             pins = {
                 pos_value: self._pedb.components.instances[self.positive_terminal_info.reference_designator].pins[
@@ -403,6 +459,11 @@ class CfgCircuitElement(CfgBase):
                     )  # terminal type pin or net
                     # create pin group
                     neg_obj = self._create_pin_group(pins, self.negative_terminal_info.reference_designator, True)
+                elif neg_type == "padstack":
+                    for pds in self._pedb.layout.padstack_instances:
+                        if pds.aedt_name == neg_value:
+                            neg_obj = {neg_value: pds}
+                            break
                 elif neg_type == "pin":
                     terminal_name = f"{self.negative_terminal_info.reference_designator}_{neg_value}"
                     neg_obj = {
@@ -412,9 +473,8 @@ class CfgCircuitElement(CfgBase):
                     }
                 else:
                     raise Exception(f"Wrong negative terminal type {neg_type}.")
-                self.neg_terminal = [
-                    j.create_terminal(i) if not j.terminal else j.terminal for i, j in neg_obj.items()
-                ][0]
+                neg_term = [j.create_terminal(i) if not j.terminal else j.terminal for i, j in neg_obj.items()][0]
+                self.neg_terminal = neg_term
 
     def _get_pins(self, terminal_type, terminal_value, reference_designator):
         terminal_value = terminal_value if isinstance(terminal_value, list) else [terminal_value]

pyedb/configuration/cfg_s_parameter_models.py

@@ -36,81 +36,136 @@ 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_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.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,
+                    }
+                )
+            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 __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):
-        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}
-                )
-
-            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)
+        self.api.apply()
 
     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.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
+        return self.api.get_data_from_db(cfg_components)