pyedb 0.31.0__py3-none-any.whl → 0.34.1__py3-none-any.whl

pyedb/configuration/cfg_padstacks.py

@@ -21,6 +21,11 @@
 # SOFTWARE.
 
 from pyedb.configuration.cfg_common import CfgBase
+from pyedb.dotnet.edb_core.general import (
+    convert_py_list_to_net_list,
+    pascal_to_snake,
+    snake_to_pascal,
+)
 
 
 class CfgPadstacks:
@@ -30,90 +35,349 @@ class CfgPadstacks:
         self._pedb = pedb
         self.definitions = []
         self.instances = []
+
         if padstack_dict:
+            padstack_defs_layout = self._pedb.padstacks.definitions
             for pdef in padstack_dict.get("definitions", []):
-                self.definitions.append(Definition(**pdef))
+                obj = padstack_defs_layout[pdef["name"]]
+                self.definitions.append(CfgPadstackDefinition(self._pedb, obj, **pdef))
+
+            inst_from_layout = self._pedb.padstacks.instances_by_name
             for inst in padstack_dict.get("instances", []):
-                self.instances.append(Instance(**inst))
+                obj = inst_from_layout[inst["name"]]
+                self.instances.append(CfgPadstackInstance(self._pedb, obj, **inst))
+
+    def clean(self):
+        self.definitions = []
+        self.instances = []
 
     def apply(self):
         """Apply padstack definition and instances on layout."""
         if self.definitions:
-            padstack_defs_layout = self._pedb.padstacks.definitions
             for pdef in self.definitions:
-                pdef_layout = padstack_defs_layout[pdef.name]
-                pdef_layout.set_properties(**pdef.get_attributes())
+                pdef.set_parameters_to_edb()
         if self.instances:
-            instances_layout = self._pedb.padstacks.instances_by_name
             for inst in self.instances:
-                inst_layout = instances_layout[inst.name]
-                data = dict()
-                data["backdrill_parameters"] = inst.backdrill_parameters
-                data["hole_override_enabled"] = inst.hole_override_enabled
-                data["hole_override_diameter"] = inst.hole_override_diameter
-                inst_layout.properties = data
-
-    def get_data_from_db(self):
-        self.definitions = []
-        for pdef_name, pdef in self._pedb.padstacks.definitions.items():
-            self.definitions.append(
-                Definition(
-                    name=pdef_name,
-                    hole_plating_thickness=pdef.hole_plating_thickness,
-                    hole_material=pdef.material,
-                    hole_range=pdef.hole_range,
-                    pad_parameters=pdef.pad_parameters,
-                    hole_parameters=pdef.hole_parameters,
-                )
-            )
-        data = {}
-        definitions = []
-        for i in self.definitions:
-            definitions.append(i.get_attributes())
-        data["definitions"] = definitions
+                inst.set_parameters_to_edb()
+
+    def retrieve_parameters_from_edb(self):
+        self.clean()
+        for name, obj in self._pedb.padstacks.definitions.items():
+            if name.lower() == "symbol":
+                continue
+            pdef = CfgPadstackDefinition(self._pedb, obj)
+            pdef.retrieve_parameters_from_edb()
+            self.definitions.append(pdef)
 
         for obj in self._pedb.layout.padstack_instances:
-            temp = obj.properties
-            self.instances.append(
-                Instance(
-                    name=temp["name"],
-                    definition=temp["definition"],
-                    backdrill_parameters=temp["backdrill_parameters"],
-                    id=temp["id"],
-                    position=temp["position"],
-                    rotation=temp["rotation"],
-                    hole_override_enabled=temp["hole_override_enabled"],
-                    hole_override_diameter=temp["hole_override_diameter"],
-                )
-            )
-        instances = []
-        for i in self.instances:
-            instances.append(i.get_attributes("id"))
-        data["instances"] = instances
-        return data
+            inst = CfgPadstackInstance(self._pedb, obj)
+            inst.retrieve_parameters_from_edb()
+            self.instances.append(inst)
 
 
-class Definition(CfgBase):
+class CfgPadstackDefinition(CfgBase):
     """Padstack definition data class."""
 
-    def __init__(self, **kwargs):
+    PAD_SHAPE_PARAMETERS = {
+        "circle": ["diameter"],
+        "square": ["size"],
+        "rectangle": ["x_size", "y_size"],
+        "oval": ["x_size", "y_size", "corner_radius"],
+        "bullet": ["x_size", "y_size", "corner_radius"],
+        "round45": ["inner", "channel_width", "isolation_gap"],
+        "round90": ["inner", "channel_width", "isolation_gap"],
+        "no_geometry": [],
+    }
+
+    def __init__(self, pedb, pedb_object, **kwargs):
+        self._pedb = pedb
+        self._pyedb_obj = pedb_object
         self.name = kwargs.get("name", None)
         self.hole_plating_thickness = kwargs.get("hole_plating_thickness", None)
         self.material = kwargs.get("hole_material", None)
         self.hole_range = kwargs.get("hole_range", None)
         self.pad_parameters = kwargs.get("pad_parameters", None)
         self.hole_parameters = kwargs.get("hole_parameters", None)
+        self.solder_ball_parameters = kwargs.get("solder_ball_parameters", None)
+
+        self._solder_shape_type = {
+            "no_solder_ball": self._pedb._edb.Definition.SolderballShape.NoSolderball,
+            "cylinder": self._pedb._edb.Definition.SolderballShape.Cylinder,
+            "spheroid": self._pedb._edb.Definition.SolderballShape.Spheroid,
+        }
+        self._solder_placement = {
+            "above_padstack": self._pedb._edb.Definition.SolderballPlacement.AbovePadstack,
+            "below_padstack": self._pedb._edb.Definition.SolderballPlacement.BelowPadstack,
+        }
+
+    def set_parameters_to_edb(self):
+        if self.hole_parameters:
+            self._set_hole_parameters_to_edb(self.hole_parameters)
+        if self.hole_range:
+            self._pyedb_obj.hole_range = self.hole_range
+        if self.hole_plating_thickness:
+            self._pyedb_obj.hole_plating_thickness = self.hole_plating_thickness
+        if self.material:
+            self._pyedb_obj.material = self.material
+        if self.pad_parameters:
+            self._set_pad_parameters_to_edb(self.pad_parameters)
+        if self.solder_ball_parameters:
+            self._set_solder_parameters_to_edb(self.solder_ball_parameters)
+
+    def _set_solder_parameters_to_edb(self, parameters):
+        pdef_data = self._pyedb_obj._padstack_def_data
+
+        shape = parameters.get("shape", "no_solder_ball")
+        diameter = parameters.get("diameter", "0.4mm")
+        mid_diameter = parameters.get("mid_diameter", diameter)
+        placement = parameters.get("placement", "above_padstack")
+        material = parameters.get("material", None)
+
+        pdef_data.SetSolderBallShape(self._solder_shape_type[shape])
+        if not shape == "no_solder_ball":
+            pdef_data.SetSolderBallParameter(self._pedb.edb_value(diameter), self._pedb.edb_value(mid_diameter))
+            pdef_data.SetSolderBallPlacement(self._solder_placement[placement])
 
+        if material:
+            pdef_data.SetSolderBallMaterial(material)
+        self._pyedb_obj._padstack_def_data = pdef_data
+
+    def _get_solder_parameters_from_edb(self):
+        pdef_data = self._pyedb_obj._padstack_def_data
+        shape = pdef_data.GetSolderBallShape()
+        _, diameter, mid_diameter = pdef_data.GetSolderBallParameterValue()
+        placement = pdef_data.GetSolderBallPlacement()
+        material = pdef_data.GetSolderBallMaterial()
+
+        parameters = {
+            "shape": [i for i, j in self._solder_shape_type.items() if j == shape][0],
+            "diameter": self._pedb.edb_value(diameter).ToString(),
+            "mid_diameter": self._pedb.edb_value(mid_diameter).ToString(),
+            "placement": [i for i, j in self._solder_placement.items() if j == placement][0],
+            "material": material,
+        }
+        return parameters
+
+    def retrieve_parameters_from_edb(self):
+        self.name = self._pyedb_obj.name
+        self.hole_plating_thickness = self._pyedb_obj.hole_plating_thickness
+        self.material = self._pyedb_obj.material
+        self.hole_range = self._pyedb_obj.hole_range
+        self.pad_parameters = self._get_pad_parameters_from_edb()
+        self.hole_parameters = self._get_hole_parameters_from_edb()
+        self.solder_ball_parameters = self._get_solder_parameters_from_edb()
+
+    def _get_pad_parameters_from_edb(self):
+        """Pad parameters.
+
+        Returns
+        -------
+        dict
+            params = {
+            'regular_pad': [
+                {'layer_name': '1_Top', 'shape': 'circle', 'offset_x': '0.1mm', 'offset_y': '0', 'rotation': '0',
+                 'diameter': '0.5mm'}
+            ],
+            'anti_pad': [
+                {'layer_name': '1_Top', 'shape': 'circle', 'offset_x': '0', 'offset_y': '0', 'rotation': '0',
+                'diameter': '1mm'}
+            ],
+            'thermal_pad': [
+                {'layer_name': '1_Top', 'shape': 'round90', 'offset_x': '0', 'offset_y': '0', 'rotation': '0',
+                'inner': '1mm', 'channel_width': '0.2mm', 'isolation_gap': '0.3mm'},
+            ],
+            'hole': [
+                {'layer_name': '1_Top', 'shape': 'circle', 'offset_x': '0', 'offset_y': '0', 'rotation': '0',
+                 'diameter': '0.1499997mm'},
+            ]
+        }
+        """
+        pdef_data = self._pyedb_obj._padstack_def_data
+        pad_type_list = [
+            self._pedb._edb.Definition.PadType.RegularPad,
+            self._pedb._edb.Definition.PadType.AntiPad,
+            self._pedb._edb.Definition.PadType.ThermalPad,
+            # self._ppadstack._pedb._edb.Definition.PadType.Hole,
+            # This property doesn't appear in UI. It is unclear what it is used for. Suppressing this property for now.
+        ]
+        data = {}
+        for pad_type in pad_type_list:
+            pad_type_name = pascal_to_snake(pad_type.ToString())
+            temp_list = []
+            for lyr_name in list(pdef_data.GetLayerNames()):
+                result = pdef_data.GetPadParametersValue(lyr_name, pad_type)
+                _, pad_shape, params, offset_x, offset_y, rotation = result
+                pad_shape = pascal_to_snake(pad_shape.ToString())
 
-class Instance(CfgBase):
+                pad_params = {}
+                pad_params["layer_name"] = lyr_name
+                pad_params["shape"] = pad_shape
+                pad_params["offset_x"] = offset_x.ToString()
+                pad_params["offset_y"] = offset_y.ToString()
+                pad_params["rotation"] = rotation.ToString()
+
+                for idx, i in enumerate(self.PAD_SHAPE_PARAMETERS[pad_shape]):
+                    pad_params[i] = params[idx].ToString()
+                temp_list.append(pad_params)
+            data[pad_type_name] = temp_list
+        return data
+
+    def _set_pad_parameters_to_edb(self, param):
+        pdef_data = self._pyedb_obj._padstack_def_data
+
+        pad_type_list = [
+            self._pedb._edb.Definition.PadType.RegularPad,
+            self._pedb._edb.Definition.PadType.AntiPad,
+            self._pedb._edb.Definition.PadType.ThermalPad,
+            self._pedb._edb.Definition.PadType.Hole,
+        ]
+        for pad_type in pad_type_list:
+            pad_type_name = pascal_to_snake(pad_type.ToString())
+            rpp = param.get(pad_type_name, [])
+            for idx, layer_data in enumerate(rpp):
+                # Get geometry type from kwargs
+                p = layer_data.get("shape")
+                temp_param = []
+
+                # Handle Circle geometry type
+                if p == pascal_to_snake(self._pedb._edb.Definition.PadGeometryType.Circle.ToString()):
+                    temp_param.append(layer_data["diameter"])
+                    pad_shape = self._pedb._edb.Definition.PadGeometryType.Circle
+
+                # Handle Square geometry type
+                elif p == pascal_to_snake(self._pedb._edb.Definition.PadGeometryType.Square.ToString()):
+                    temp_param.append(layer_data["size"])
+                    pad_shape = self._pedb._edb.Definition.PadGeometryType.Square
+
+                elif p == pascal_to_snake(self._pedb._edb.Definition.PadGeometryType.Rectangle.ToString()):
+                    temp_param.append(layer_data["x_size"])
+                    temp_param.append(layer_data["y_size"])
+                    pad_shape = self._pedb._edb.Definition.PadGeometryType.Rectangle
+
+                # Handle Oval geometry type
+                elif p == pascal_to_snake(self._pedb._edb.Definition.PadGeometryType.Oval.ToString()):
+                    temp_param.append(layer_data["x_size"])
+                    temp_param.append(layer_data["y_size"])
+                    temp_param.append(layer_data["corner_radius"])
+                    pad_shape = self._pedb._edb.Definition.PadGeometryType.Oval
+
+                # Handle Bullet geometry type
+                elif p == pascal_to_snake(self._pedb._edb.Definition.PadGeometryType.Bullet.ToString()):
+                    temp_param.append(layer_data["x_size"])
+                    temp_param.append(layer_data["y_size"])
+                    temp_param.append(layer_data["corner_radius"])
+                    pad_shape = self._pedb._edb.Definition.PadGeometryType.Bullet
+
+                # Handle Round45 geometry type
+                elif p == pascal_to_snake(self._pedb._edb.Definition.PadGeometryType.Round45.ToString()):
+                    temp_param.append(layer_data["inner"])
+                    temp_param.append(layer_data["channel_width"])
+                    temp_param.append(layer_data["isolation_gap"])
+                    pad_shape = self._pedb._edb.Definition.PadGeometryType.Round45
+
+                # Handle Round90 geometry type
+                elif p == pascal_to_snake(self._pedb._edb.Definition.PadGeometryType.Round90.ToString()):
+                    temp_param.append(layer_data["inner"])
+                    temp_param.append(layer_data["channel_width"])
+                    temp_param.append(layer_data["isolation_gap"])
+                    pad_shape = self._pedb._edb.Definition.PadGeometryType.Round90
+                elif p == pascal_to_snake(self._pedb._edb.Definition.PadGeometryType.NoGeometry.ToString()):
+                    continue
+
+                # Set pad parameters for the current layer
+                pdef_data.SetPadParameters(
+                    layer_data["layer_name"],
+                    pad_type,
+                    pad_shape,
+                    convert_py_list_to_net_list([self._pedb.edb_value(i) for i in temp_param]),
+                    self._pedb.edb_value(layer_data.get("offset_x", 0)),
+                    self._pedb.edb_value(layer_data.get("offset_y", 0)),
+                    self._pedb.edb_value(layer_data.get("rotation", 0)),
+                )
+        self._pyedb_obj._padstack_def_data = pdef_data
+
+    def _get_hole_parameters_from_edb(self):
+        pdef_data = self._pyedb_obj._padstack_def_data
+        _, hole_shape, params, offset_x, offset_y, rotation = pdef_data.GetHoleParametersValue()
+        hole_shape = pascal_to_snake(hole_shape.ToString())
+
+        hole_params = {}
+        hole_params["shape"] = hole_shape
+        for idx, i in enumerate(self.PAD_SHAPE_PARAMETERS[hole_shape]):
+            hole_params[i] = params[idx].ToString()
+        hole_params["offset_x"] = offset_x.ToString()
+        hole_params["offset_y"] = offset_y.ToString()
+        hole_params["rotation"] = rotation.ToString()
+        return hole_params
+
+    def _set_hole_parameters_to_edb(self, params):
+        original_params = self.hole_parameters
+        pdef_data = self._pyedb_obj._padstack_def_data
+
+        temp_param = []
+        shape = params["shape"]
+        if shape == "no_geometry":
+            return  # .net api doesn't tell how to set no_geometry shape.
+        for idx, i in enumerate(self.PAD_SHAPE_PARAMETERS[shape]):
+            temp_param.append(params[i])
+            pedb_shape = getattr(self._pedb._edb.Definition.PadGeometryType, snake_to_pascal(shape))
+
+        pdef_data.SetHoleParameters(
+            pedb_shape,
+            convert_py_list_to_net_list([self._pedb.edb_value(i) for i in temp_param]),
+            self._pedb.edb_value(params.get("offset_x", original_params.get("offset_x", 0))),
+            self._pedb.edb_value(params.get("offset_y", original_params.get("offset_y", 0))),
+            self._pedb.edb_value(params.get("rotation", original_params.get("rotation", 0))),
+        )
+        self._pyedb_obj._padstack_def_data = pdef_data
+
+
+class CfgPadstackInstance(CfgBase):
     """Instance data class."""
 
-    def __init__(self, **kwargs):
-        self.name = kwargs["name"]
+    def __init__(self, pedb, pyedb_obj, **kwargs):
+        self._pedb = pedb
+        self._pyedb_obj = pyedb_obj
+        self.name = kwargs.get("name", None)
+        self.net_name = kwargs.get("net_name", "")
+        self.layer_range = kwargs.get("layer_range", [None, None])
         self.definition = kwargs.get("definition", None)
         self.backdrill_parameters = kwargs.get("backdrill_parameters", None)
-        self.id = kwargs.get("id", None)
+        self._id = kwargs.get("id", None)
         self.position = kwargs.get("position", [])
         self.rotation = kwargs.get("rotation", None)
         self.hole_override_enabled = kwargs.get("hole_override_enabled", None)
         self.hole_override_diameter = kwargs.get("hole_override_diameter", None)
+        self.solder_ball_layer = kwargs.get("solder_ball_layer", None)
+
+    def set_parameters_to_edb(self):
+        if self.name is not None:
+            self._pyedb_obj.aedt_name = self.name
+        if self.net_name is not None:
+            self._pyedb_obj.net_name = self._pedb.nets.find_or_create_net(self.net_name).name
+        if self.layer_range[0] is not None:
+            self._pyedb_obj.start_layer = self.layer_range[0]
+        if self.layer_range[1] is not None:
+            self._pyedb_obj.stop_layer = self.layer_range[1]
+        if self.backdrill_parameters:
+            self._pyedb_obj.backdrill_parameters = self.backdrill_parameters
+        if self.solder_ball_layer:
+            self._pyedb_obj._edb_object.SetSolderBallLayer(self._pedb.stackup[self.solder_ball_layer]._edb_object)
+
+        hole_override_enabled, hole_override_diam = self._pyedb_obj._edb_object.GetHoleOverrideValue()
+        hole_override_enabled = self.hole_override_enabled if self.hole_override_enabled else hole_override_enabled
+        hole_override_diam = self.hole_override_diameter if self.hole_override_diameter else hole_override_diam
+        self._pyedb_obj._edb_object.SetHoleOverride(hole_override_enabled, self._pedb.edb_value(hole_override_diam))
+
+    def retrieve_parameters_from_edb(self):
+        self.name = self._pyedb_obj.aedt_name
+        self.definition = self._pyedb_obj.padstack_definition
+        self.backdrill_parameters = self._pyedb_obj.backdrill_parameters
+        _, position, rotation = self._pyedb_obj._edb_object.GetPositionAndRotationValue()
+        self.position = [position.X.ToString(), position.Y.ToString()]
+        self.rotation = rotation.ToString()
+        self._id = self._pyedb_obj.id
+        self.hole_override_enabled, hole_override_diameter = self._pyedb_obj._edb_object.GetHoleOverrideValue()
+        self.hole_override_diameter = hole_override_diameter.ToString()
+        self.solder_ball_layer = self._pyedb_obj._edb_object.GetSolderBallLayer().GetName()
+        self.layer_range = [self._pyedb_obj.start_layer, self._pyedb_obj.stop_layer]

pyedb/configuration/cfg_ports_sources.py

@@ -21,6 +21,9 @@
 # SOFTWARE.
 
 from pyedb.configuration.cfg_common import CfgBase
+from pyedb.dotnet.edb_core.edb_data.ports import WavePort
+from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
+from pyedb.dotnet.edb_core.geometry.point_data import PointData
 
 
 class CfgTerminalInfo(CfgBase):
@@ -65,7 +68,7 @@ class CfgSources:
 
     def apply(self):
         for src in self.sources:
-            src.create()
+            src.set_parameters_to_edb()
 
     def get_data_from_db(self):
         self.sources = []
@@ -114,11 +117,28 @@ class CfgSources:
 class CfgPorts:
     def __init__(self, pedb, ports_data):
         self._pedb = pedb
-        self.ports = [CfgPort(self._pedb, **p) for p in ports_data]
+
+        self.ports = []
+        for p in ports_data:
+            if p["type"] == "wave_port":
+                self.ports.append(CfgWavePort(self._pedb, **p))
+            elif p["type"] == "diff_wave_port":
+                self.ports.append(CfgDiffWavePort(self._pedb, **p))
+            elif p["type"] in ["coax", "circuit"]:
+                self.ports.append(CfgPort(self._pedb, **p))
+            else:
+                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 p in self.ports:
-            p.create()
+            if p.type in ["wave_port", "diff_wave_port"]:
+                p.set_parameters_to_edb(edb_primitives)
+            else:
+                p.set_parameters_to_edb()
 
     def get_data_from_db(self):
         self.ports = []
@@ -188,8 +208,8 @@ class CfgPorts:
 class CfgCircuitElement(CfgBase):
     def __init__(self, pedb, **kwargs):
         self._pedb = pedb
-        self.name = kwargs.get("name", None)
-        self.type = kwargs.get("type", None)
+        self.name = kwargs["name"]
+        self.type = kwargs["type"]
         self.reference_designator = kwargs.get("reference_designator", None)
         self.distributed = kwargs.get("distributed", False)
 
@@ -321,7 +341,7 @@ class CfgPort(CfgCircuitElement):
     def __init__(self, pedb, **kwargs):
         super().__init__(pedb, **kwargs)
 
-    def create(self):
+    def set_parameters_to_edb(self):
         """Create port."""
         self._create_terminals()
         is_circuit_port = True if self.type == "circuit" else False
@@ -356,7 +376,7 @@ class CfgSource(CfgCircuitElement):
 
         self.magnitude = kwargs.get("magnitude", 0.001)
 
-    def create(self):
+    def set_parameters_to_edb(self):
         """Create sources."""
         self._create_terminals()
         # is_circuit_port = True if self.type == "circuit" else False
@@ -385,3 +405,75 @@ class CfgSource(CfgCircuitElement):
             "positive_terminal": self.positive_terminal_info.export_properties(),
             "negative_terminal": self.negative_terminal_info.export_properties(),
         }
+
+
+class CfgWavePort:
+    def __init__(self, pedb, **kwargs):
+        self._pedb = pedb
+        self.name = kwargs["name"]
+        self.type = kwargs["type"]
+        self.primitive_name = kwargs["primitive_name"]
+        self.point_on_edge = kwargs["point_on_edge"]
+        self.horizontal_extent_factor = kwargs.get("horizontal_extent_factor", 5)
+        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):
+        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
+        wave_port.hfss_type = "Wave"
+        wave_port.do_renormalize = True
+        return wave_port
+
+
+class CfgDiffWavePort:
+    def __init__(self, pedb, **kwargs):
+        self._pedb = pedb
+        self.name = kwargs["name"]
+        self.type = kwargs["type"]
+        self.horizontal_extent_factor = kwargs.get("horizontal_extent_factor", 5)
+        self.vertical_extent_factor = kwargs.get("vertical_extent_factor", 3)
+        self.pec_launch_width = kwargs.get("pec_launch_width", "0.01mm")
+
+        kwargs["positive_terminal"]["type"] = "wave_port"
+        kwargs["positive_terminal"]["name"] = self.name + ":T1"
+        self.positive_port = CfgWavePort(
+            self._pedb,
+            horizontal_extent_factor=self.horizontal_extent_factor,
+            vertical_extent_factor=self.vertical_extent_factor,
+            pec_launch_width=self.pec_launch_width,
+            **kwargs["positive_terminal"],
+        )
+        kwargs["negative_terminal"]["type"] = "wave_port"
+        kwargs["negative_terminal"]["name"] = self.name + ":T2"
+        self.negative_port = CfgWavePort(
+            self._pedb,
+            horizontal_extent_factor=self.horizontal_extent_factor,
+            vertical_extent_factor=self.vertical_extent_factor,
+            pec_launch_width=self.pec_launch_width,
+            **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)
+        edb_list = convert_py_list_to_net_list(
+            [pos_term._edb_object, neg_term._edb_object], self._pedb.edb_api.cell.terminal.Terminal
+        )
+        _edb_boundle_terminal = self._pedb.edb_api.cell.terminal.BundleTerminal.Create(edb_list)
+        _edb_boundle_terminal.SetName(self.name)
+        pos, neg = list(_edb_boundle_terminal.GetTerminals())
+        pos.SetName(self.name + ":T1")
+        neg.SetName(self.name + ":T2")

pyedb/configuration/cfg_s_parameter_models.py

@@ -67,7 +67,7 @@ class CfgSParameters:
                     ref_net = s_param.reference_net
                 comp.use_s_parameter_model(s_param.name, reference_net=ref_net)
 
-    def get_data_from_db(self):
+    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
@@ -75,16 +75,16 @@ class CfgSParameters:
                 continue
             else:
                 pin_order = compdef_obj.get_properties()["pin_order"]
-                temp_comps = compdef_obj.components
+                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.values():
-                        s_param_model = i.model_properties.get("s_parameter_model")
+                    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.refdes)
-                                reference_net_per_component[i.refdes] = s_param_model["reference_net"]
+                                temp_comp_list.append(i["reference_designator"])
+                                reference_net_per_component[i["reference_designator"]] = s_param_model["reference_net"]
                         else:
                             continue