pyedb 0.43.0__py3-none-any.whl → 0.45.0__py3-none-any.whl

pyedb/configuration/cfg_pin_groups.py

@@ -40,7 +40,7 @@ class CfgPinGroups:
             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
+                    pins = list(pg_obj.pins.values())
                     refdes = pins[0].component.name
                     cfg_pg = CfgPinGroup(
                         self._pedb,

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)
 
@@ -84,8 +108,27 @@ 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 __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):
@@ -104,18 +147,18 @@ class CfgSources:
 
             if src.terminal_type == "PinGroupTerminal":
                 refdes = ""
-                pg = self._pedb.siwave.pin_groups[src._edb_object.GetPinGroup().GetName()]
+                pg = self._pedb.siwave.pin_groups[self.api.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 ""
-                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()]
+                pg = self._pedb.siwave.pin_groups[self.api.get_pin_group_name(neg_term)]
                 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,13 +180,74 @@ 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
+
+    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 _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
+
     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":
                 self.ports.append(CfgEdgePort(self._pedb, **p))
+            elif p["type"] == "gap_port":
+                self.ports.append(CfgEdgePort(self._pedb, **p))
             elif p["type"] == "diff_wave_port":
                 self.ports.append(CfgDiffWavePort(self._pedb, **p))
             elif p["type"] in ["coax", "circuit"]:
@@ -156,8 +260,11 @@ 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"]:
+            if p.type in ["wave_port", "diff_wave_port", "gap_port"]:
                 p.set_parameters_to_edb(edb_primitives)
             else:
                 p.set_parameters_to_edb()
@@ -171,20 +278,22 @@ class CfgPorts:
             if not p.ref_terminal:
                 if p.terminal_type == "PadstackInstanceTerminal":
                     port_type = "coax"
-                elif p.hfss_type == "Wave":
-                    port_type = "wave_port"
+                elif p.terminal_type == "PinGroupTerminal":
+                    port_type = "circuit"
+                elif p.terminal_type == "EdgeTerminal":
+                    port_type = "wave_port" if p.hfss_type == "Wave" else "gap_port"
                 else:
-                    port_type = "gap_port"
+                    raise ValueError("Unknown terminal type")
             else:
                 port_type = "circuit"
 
             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 +301,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": {
@@ -222,22 +332,7 @@ class CfgPorts:
                     positive_terminal=pos_term_info,
                 )
             else:
-                _, 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,
-                )
-
+                cfg_port = self.api._get_edge_port_from_edb(p, port_type)
             self.ports.append(cfg_port)
         return self.export_properties()
 
@@ -269,7 +364,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 +374,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 +401,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 +503,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 +517,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]
@@ -663,8 +767,99 @@ class CfgProbe(CfgCircuitElement):
 
 
 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, 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 __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"]
@@ -674,37 +869,10 @@ class CfgEdgePort:
         self.pec_launch_width = kwargs.get("pec_launch_width", "0.01mm")
 
     def set_parameters_to_edb(self, edb_primitives):
-        point_on_edge = PointData(self._pedb, x=self.point_on_edge[0], y=self.point_on_edge[1])
-        primitive = edb_primitives[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
+        return self.api.set_parameters_to_edb(edb_primitives)
 
     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,
-        }
+        return self.api.export_properties()
 
 
 class CfgDiffWavePort:

pyedb/configuration/cfg_s_parameter_models.py

@@ -80,7 +80,7 @@ class CfgSParameters:
                 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():
+                    for model_obj in nport_models:
                         temp_comp_list = []
                         reference_net_per_component = {}
                         for i in temp_comps:
@@ -125,6 +125,86 @@ class CfgSParameters:
         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
+                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
+
     def __init__(self, pedb, data, path_lib=None):
         self._pedb = pedb
         if self._pedb.grpc: