pyedb 0.27.0__py3-none-any.whl → 0.29.0__py3-none-any.whl

pyedb/__init__.py

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

pyedb/configuration/cfg_boundaries.py

@@ -20,97 +20,50 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-from enum import Enum
+from pyedb.configuration.cfg_common import CfgBase
 
 
-class CfgBoundaries:
-    def __init__(self, pdata, boundaries_dict):
-        self._pedb = pdata._pedb
-        self._boundaries_dict = boundaries_dict
-        self.open_region = self._boundaries_dict.get("open_region", None)
-        self._map_open_region_type()
-        self.pml_visible = self._boundaries_dict.get("pml_visible", None)
-        self.pml_operation_frequency = self._boundaries_dict.get("pml_operation_frequency", None)
-        self.pml_radiation_factor = self._boundaries_dict.get("pml_radiation_factor", None)
-        self._map_dielectric_extend_type()
-        self.dielectric_base_polygon = self._boundaries_dict.get("dielectric_base_polygon", None)
-        self.horizontal_padding = self._boundaries_dict.get("horizontal_padding", None)
-        self.honor_primitives_on_dielectric_layers = self._boundaries_dict.get(
-            "honor_primitives_on_dielectric_layers", False
-        )
-        self._map_air_box_extend_type()
-        self.air_box_base_polygon = self._boundaries_dict.get("air_box_base_polygon", None)
-        self.air_box_truncate_model_ground_layers = self._boundaries_dict.get(
-            "air_box_truncate_model_ground_layers", None
-        )
-        self.air_box_horizontal_padding = self._boundaries_dict.get("air_box_horizontal_padding", None)
-        self.air_box_positive_vertical_padding = self._boundaries_dict.get("air_box_positive_vertical_padding", None)
-        self.air_box_negative_vertical_padding = self._boundaries_dict.get("air_box_negative_vertical_padding", None)
-
-    def _map_air_box_extend_type(self):
-        air_box_type = self._boundaries_dict.get("air_box_extents_type", None)
-        if air_box_type == "bounding_box":
-            self.air_box_extents_type = self.ExtentType.BOUNDING_BOX
-        elif air_box_type == "conformal":
-            self.air_box_extents_type = self.ExtentType.CONFORMAL
-        elif air_box_type == "convex_hull":
-            self.air_box_extents_type = self.ExtentType.CONVEX_HULL
-        elif air_box_type == "polygon":
-            self.air_box_extents_type = self.ExtentType.POLYGON
-        else:
-            self.air_box_extents_type = self.ExtentType.BOUNDING_BOX
-
-    def _map_open_region_type(self):
-        open_region = self._boundaries_dict.get("open_region_type", None)
-        if open_region == "radiation":
-            self.open_region_type = self.OpenRegionType.RADIATION
-        elif open_region == "pec":
-            self.open_region_type = self.OpenRegionType.PEC
-        else:
-            self.open_region_type = self.OpenRegionType.RADIATION
-
-    def _map_dielectric_extend_type(self):
-        extend_type = self._boundaries_dict.get("dielectric_extents_type", None)
-        if extend_type == "bounding_box":
-            self.dielectric_extents_type = self.ExtentType.BOUNDING_BOX
-        elif extend_type == "conformal":
-            self.dielectric_extents_type = self.ExtentType.CONFORMAL
-        elif extend_type == "convex_hull":
-            self.dielectric_extents_type = self.ExtentType.CONVEX_HULL
-        elif extend_type == "polygon":
-            self.dielectric_extents_type = self.ExtentType.POLYGON
-        else:
-            self.dielectric_extents_type = self.ExtentType.BOUNDING_BOX
-
-    class OpenRegionType(Enum):
-        RADIATION = 0
-        PEC = 1
-
-    class ExtentType(Enum):
-        BOUNDING_BOX = 0
-        CONFORMAL = 1
-        CONVEX_HULL = 2
-        POLYGON = 3
+class CfgBoundaries(CfgBase):
+    def __init__(self, pedb, boundary_data):
+        self._pedb = pedb
+        self.open_region = boundary_data.get("open_region", None)
+        self.open_region_type = boundary_data.get("map_open_region_type", None)
+        self.pml_visible = boundary_data.get("pml_visible", None)
+        self.pml_operation_frequency = boundary_data.get("pml_operation_frequency", None)
+        self.pml_radiation_factor = boundary_data.get("pml_radiation_factor", None)
+        self.dielectric_extent_type = boundary_data.get("dielectric_extent_type", None)
+        # self.dielectric_base_polygon = self.**kwargs.get("dielectric_base_polygon", None)
+        self.horizontal_padding = boundary_data.get("horizontal_padding", None)
+        self.honor_primitives_on_dielectric_layers = boundary_data.get("honor_primitives_on_dielectric_layers", False)
+        self.air_box_extent_type = boundary_data.get("air_box_extent_type", None)
+        self.air_box_base_polygon = boundary_data.get("air_box_base_polygon", None)
+        self.air_box_truncate_model_ground_layers = boundary_data.get("air_box_truncate_model_ground_layers", None)
+        self.air_box_horizontal_padding = boundary_data.get("air_box_horizontal_padding", None)
+        self.air_box_positive_vertical_padding = boundary_data.get("air_box_positive_vertical_padding", None)
+        self.air_box_negative_vertical_padding = boundary_data.get("air_box_negative_vertical_padding", None)
 
     def apply(self):
         """Imports boundary information from JSON."""
         if self.open_region is not None:
             self._pedb.hfss.hfss_extent_info.use_open_region = self.open_region
-        self._pedb.hfss.hfss_extent_info.open_region_type = self.open_region_type.name.lower()
+        if self.open_region_type:
+            self._pedb.hfss.hfss_extent_info.open_region_type = self.open_region_type.lower()
         if self.pml_visible is not None:
             self._pedb.hfss.hfss_extent_info.is_pml_visible = self.pml_visible
         if self.pml_operation_frequency:
             self._pedb.hfss.hfss_extent_info.operating_freq = self.pml_operation_frequency
         if self.pml_radiation_factor:
             self._pedb.hfss.hfss_extent_info.radiation_level = self.pml_radiation_factor
-        self._pedb.hfss.hfss_extent_info.extent_type = self.dielectric_extents_type.name.lower()
-        if self.dielectric_base_polygon:
-            self._pedb.hfss.hfss_extent_info.dielectric_base_polygon = self.dielectric_base_polygon
+        if self.dielectric_extent_type:
+            self._pedb.hfss.hfss_extent_info.extent_type = self.dielectric_extent_type.lower()
+        # if self.dielectric_base_polygon:
+        #    self._pedb.hfss.hfss_extent_info.dielectric_base_polygon = self.dielectric_base_polygon
         if self.horizontal_padding:
             self._pedb.hfss.hfss_extent_info.dielectric_extent_size = float(self.horizontal_padding)
         if self.honor_primitives_on_dielectric_layers is not None:
             self._pedb.hfss.hfss_extent_info.honor_user_dielectric = self.honor_primitives_on_dielectric_layers
-        self._pedb.hfss.hfss_extent_info.extent_type = self.air_box_extents_type.name.lower()
+        if self.air_box_extent_type:
+            self._pedb.hfss.hfss_extent_info.extent_type = self.air_box_extent_type.lower()
         if self.air_box_truncate_model_ground_layers is not None:
             self._pedb.hfss.hfss_extent_info.truncate_air_box_at_ground = self.air_box_truncate_model_ground_layers
         if self.air_box_horizontal_padding:
@@ -123,3 +76,20 @@ class CfgBoundaries:
             self._pedb.hfss.hfss_extent_info.air_box_negative_vertical_extent = float(
                 self.air_box_negative_vertical_padding
             )
+
+    def get_data_from_db(self):
+        self.open_region = self._pedb.hfss.hfss_extent_info.use_open_region
+        self.open_region_type = self._pedb.hfss.hfss_extent_info.open_region_type
+        self.pml_visible = self._pedb.hfss.hfss_extent_info.is_pml_visible
+        self.pml_operation_frequency = self._pedb.hfss.hfss_extent_info.operating_freq.tostring
+        self.pml_radiation_factor = self._pedb.hfss.hfss_extent_info.radiation_level.tostring
+        self.dielectric_extent_type = self._pedb.hfss.hfss_extent_info.extent_type
+        # self.dielectric_base_polygon = self._pedb.hfss.hfss_extent_info.dielectric_base_polygon
+        self.horizontal_padding = self._pedb.hfss.hfss_extent_info.dielectric_extent_size
+        self.honor_primitives_on_dielectric_layers = self._pedb.hfss.hfss_extent_info.honor_user_dielectric
+        self.air_box_extent_type = self._pedb.hfss.hfss_extent_info.extent_type
+        self.air_box_truncate_model_ground_layers = self._pedb.hfss.hfss_extent_info.truncate_air_box_at_ground
+        self.air_box_horizontal_padding = self._pedb.hfss.hfss_extent_info.air_box_horizontal_extent
+        self.air_box_positive_vertical_padding = self._pedb.hfss.hfss_extent_info.air_box_positive_vertical_extent
+        self.air_box_negative_vertical_padding = self._pedb.hfss.hfss_extent_info.air_box_negative_vertical_extent
+        return self.get_attributes()

pyedb/configuration/cfg_common.py

@@ -30,7 +30,7 @@ class CfgBase:
             exclude = exclude if isinstance(exclude, list) else [exclude]
             attrs = {i: j for i, j in attrs.items() if i not in exclude}
         attrs = {i: j for i, j in attrs.items() if not i.startswith("_")}
-        attrs = {i: j for i, j in attrs.items() if j is not None}
+        attrs = {i: j for i, j in attrs.items() if j not in [None, [], {}]}
         return attrs
 
     def set_attributes(self, pedb_object):

pyedb/configuration/cfg_components.py

@@ -23,23 +23,6 @@
 from pyedb.configuration.cfg_common import CfgBase
 
 
-class CfgPortProperties(CfgBase):
-    def __init__(self, **kwargs):
-        self.reference_offset = kwargs.pop("reference_offset", 0)
-        self.reference_size_auto = kwargs.pop("reference_size_auto", 0)
-        self.reference_size_x = kwargs.pop("reference_size_x", 0)
-        self.reference_size_y = kwargs.pop("reference_size_y", 0)
-
-
-class CfgSolderBallsProperties(CfgBase):
-    def __init__(self, **kwargs):
-        self.shape = kwargs.pop("shape", None)
-        self.diameter = kwargs.pop("diameter", None)
-        self.mid_diameter = kwargs.pop("mid_diameter", None)
-        self.height = kwargs.pop("height", None)
-        self.enabled = kwargs.pop("enabled", None)
-
-
 class CfgRlcModel(CfgBase):
     def __init__(self, **kwargs):
         self.resistance = kwargs.get("resistance", None)
@@ -51,45 +34,17 @@ class CfgRlcModel(CfgBase):
 
 
 class CfgComponent(CfgBase):
-    protected_attributes = ["reference_designator", "definition", "location", "angle", "placement_layer"]
-
     def __init__(self, **kwargs):
         self.enabled = kwargs.get("enabled", None)
-
         self.reference_designator = kwargs.get("reference_designator", None)
         self.definition = kwargs.get("definition", None)
-        self.type = kwargs.get("part_type", None)
-        self.value = kwargs.get("value", None)
-        self.port_properties = CfgPortProperties(**kwargs["port_properties"]) if "port_properties" in kwargs else None
-        self.solder_ball_properties = (
-            CfgSolderBallsProperties(**kwargs["solder_ball_properties"]) if "solder_ball_properties" in kwargs else None
-        )
-        rlc_models = kwargs.get("rlc_model", [])
-
-        self.rlc_model = [CfgRlcModel(**rlc_m) for rlc_m in rlc_models]
-
-        self.x_location, self.y_location = kwargs.get("location", [None, None])
-        self.angle = kwargs.get("angle", None)
-        self.placement_layer = kwargs.get("placement_layer", None)
-
-    def export_properties(self):
-        """Export component properties.
-
-        Returns
-        -------
-        Dict
-        """
-        data_comp = {}
-        data_comp["enabled"] = self.enabled
-        data_comp["reference_designator"] = self.reference_designator
-        data_comp["definition"] = self.definition
-        data_comp["type"] = self.type
-        data_comp["value"] = self.value
-        data_comp["x_location"] = self.x_location
-        data_comp["y_location"] = self.y_location
-        # data_comp["angle"] = self.angle
-        data_comp["placement_layer"] = self.placement_layer
-        return data_comp
+        self.type = kwargs["part_type"].lower() if kwargs.get("part_type") else None
+        self.port_properties = kwargs.get("port_properties", {})
+        self.solder_ball_properties = kwargs.get("solder_ball_properties", {})
+        self.ic_die_properties = kwargs.get("ic_die_properties", {})
+        self.pin_pair_model = kwargs.get("pin_pair_model", None)
+        self.spice_model = kwargs.get("spice_model", None)
+        self.s_parameter_model = kwargs.get("s_parameter_model", None)
 
 
 class CfgComponents:
@@ -98,59 +53,25 @@ class CfgComponents:
         self.components = [CfgComponent(**comp) for comp in components_data]
 
     def apply(self):
-        comps_in_db = self._pedb.components
+        comps_in_db = self._pedb.components.components
         for comp in self.components:
             c_db = comps_in_db[comp.reference_designator]
-
-            for attr, value in comp.get_attributes().items():  # All component properties
-                if attr == "solder_ball_properties":
-                    solder_ball_properties = value
-                    port_properties = comp.port_properties
-                    self._pedb.components.set_solder_ball(
-                        component=comp.reference_designator,
-                        sball_diam=solder_ball_properties.diameter,
-                        sball_mid_diam=solder_ball_properties.mid_diameter,
-                        sball_height=solder_ball_properties.height,
-                        shape=solder_ball_properties.shape,
-                        auto_reference_size=port_properties.reference_size_auto,
-                        reference_height=port_properties.reference_offset,
-                        reference_size_x=port_properties.reference_size_x,
-                        reference_size_y=port_properties.reference_size_y,
-                    )
-                elif attr == "port_properties":
-                    pass
-                elif attr == "rlc_model":
-                    rlc_models = value
-                    model_layout = c_db.model
-                    for pp in model_layout.pin_pairs:
-                        model_layout.delete_pin_pair_rlc(pp)
-                    for pp in rlc_models:
-                        pin_pair = self._pedb.edb_api.utility.PinPair(pp.p1, pp.p2)
-                        rlc = self._pedb.edb_api.utility.Rlc()
-                        rlc.IsParallel = False if pp.type else True
-                        if pp.resistance is not None:
-                            rlc.REnabled = True
-                            rlc.R = self._pedb.edb_value(pp.resistance)
-                        else:
-                            rlc.REnabled = False
-                        if pp.inductance is not None:
-                            rlc.LEnabled = True
-                            rlc.L = self._pedb.edb_value(pp.inductance)
-                        else:
-                            rlc.LEnabled = False
-
-                        if pp.capacitance is not None:
-                            rlc.CEnabled = True
-                            rlc.C = self._pedb.edb_value(pp.capacitance)
-                        else:
-                            rlc.CEnabled = False
-                        model_layout._set_pin_pair_rlc(pin_pair, rlc)
-                        comps_in_db.model = model_layout
-                else:
-                    if attr in dir(c_db):
-                        setattr(c_db, attr, value)
-                    else:
-                        raise AttributeError(f"'{attr}' is not valid component attribute.")
+            if comp.definition:
+                c_db.definition = comp.definition
+            if comp.type:
+                c_db.type = comp.type
+            if comp.solder_ball_properties:
+                c_db.solder_ball_properties = comp.solder_ball_properties
+            if comp.port_properties:
+                c_db.port_properties = comp.port_properties
+            if comp.ic_die_properties:
+                c_db.set_ic_die_properties = comp.ic_die_properties
+            if comp.pin_pair_model:
+                c_db.model_properties = {"pin_pair_model": comp.pin_pair_model}
+            if comp.spice_model:
+                c_db.model_properties = {"spice_model": comp.spice_model}
+            if comp.s_parameter_model:
+                c_db.model_properties = {"s_parameter_model": comp.s_parameter_model}
 
     def _load_data_from_db(self):
         self.components = []
@@ -160,10 +81,15 @@ class CfgComponents:
                 enabled=comp.enabled,
                 reference_designator=comp.name,
                 part_type=comp.type,
-                value=comp.value,
+                pin_pair_model=comp.model_properties.get("pin_pair_model"),
+                spice_model=comp.model_properties.get("spice_model"),
+                s_parameter_model=comp.model_properties.get("s_parameter_model"),
                 definition=comp.component_def,
                 location=comp.location,
                 placement_layer=comp.placement_layer,
+                solder_ball_properties=comp.solder_ball_properties,
+                ic_die_properties=comp.ic_die_properties,
+                port_properties=comp.port_properties,
             )
             self.components.append(cfg_comp)
 
@@ -171,5 +97,5 @@ class CfgComponents:
         self._load_data_from_db()
         data = []
         for comp in self.components:
-            data.append(comp.export_properties())
+            data.append(comp.get_attributes())
         return data

pyedb/configuration/cfg_data.py

@@ -30,7 +30,7 @@ from pyedb.configuration.cfg_package_definition import CfgPackageDefinitions
 from pyedb.configuration.cfg_padstacks import CfgPadstacks
 from pyedb.configuration.cfg_pin_groups import CfgPinGroups
 from pyedb.configuration.cfg_ports_sources import CfgPorts, CfgSources
-from pyedb.configuration.cfg_s_parameter_models import CfgSParameterModel
+from pyedb.configuration.cfg_s_parameter_models import CfgSParameters
 from pyedb.configuration.cfg_setup import CfgSetups
 from pyedb.configuration.cfg_spice_models import CfgSpiceModel
 from pyedb.configuration.cfg_stackup import CfgStackup
@@ -43,9 +43,7 @@ class CfgData(object):
         self._pedb = pedb
         self.general = CfgGeneral(self, kwargs.get("general", None))
 
-        self.boundaries = {}
-        if kwargs.get("boundaries", None):
-            self.boundaries = CfgBoundaries(self, kwargs.get("boundaries", None))
+        self.boundaries = CfgBoundaries(self._pedb, kwargs.get("boundaries", {}))
 
         self.nets = CfgNets(
             self, kwargs.get("nets", {}).get("signal_nets", []), kwargs.get("nets", {}).get("power_ground_nets", [])
@@ -53,7 +51,7 @@ class CfgData(object):
 
         self.components = CfgComponents(self._pedb, components_data=kwargs.get("components", []))
 
-        self.padstacks = CfgPadstacks(self, kwargs.get("padstacks", None))
+        self.padstacks = CfgPadstacks(self._pedb, kwargs.get("padstacks", None))
 
         self.pin_groups = CfgPinGroups(self._pedb, pingroup_data=kwargs.get("pin_groups", []))
 
@@ -65,10 +63,7 @@ class CfgData(object):
 
         self.stackup = CfgStackup(self._pedb, data=kwargs.get("stackup", {}))
 
-        self.s_parameters = [
-            CfgSParameterModel(self, self.general.s_parameter_library, sparam_model)
-            for sparam_model in kwargs.get("s_parameters", [])
-        ]
+        self.s_parameters = CfgSParameters(self._pedb, kwargs.get("s_parameters", []), self.general.s_parameter_library)
 
         self.spice_models = [
             CfgSpiceModel(self, self.general.spice_model_library, spice_model)

pyedb/configuration/cfg_operations.py

@@ -53,19 +53,21 @@ class CfgCutout(CfgBase):
 
     def get_data_from_db(self):
         if "pyedb_cutout" in self._pedb.stackup.all_layers:
-            poly = self._pedb.layout.find_primitive(layer_name="pyedb_cutout")[0]
-            self.custom_extent = poly.polygon_data.points
+            polygons = self._pedb.layout.find_primitive(layer_name="pyedb_cutout")
+            if polygons:
+                poly = polygons[0]
+                self.custom_extent = poly.polygon_data.points
 
-            net_names = []
-            for name, obj in self._pedb.nets.nets.items():
-                if obj.primitives[0].layer.name == "pyedb_cutout":
-                    continue
-                if len(obj.primitives) > 0:
-                    net_names.append(name)
+                net_names = []
+                for name, obj in self._pedb.nets.nets.items():
+                    if obj.primitives[0].layer.name == "pyedb_cutout":
+                        continue
+                    if len(obj.primitives) > 0:
+                        net_names.append(name)
 
-            self.reference_list = []
-            self.signal_list = net_names
-        return self.export_properties()
+                self.reference_list = []
+                self.signal_list = net_names
+            return self.export_properties()
 
     def export_properties(self):
         return {
@@ -84,7 +86,7 @@ class CfgOperations(CfgBase):
         """Imports operation information from JSON."""
         if self.op_cutout:
             polygon_points = self._pedb.cutout(**self.op_cutout.get_attributes())
-            if not "pyedb_cutout" in self._pedb.stackup.all_layers:
+            if "pyedb_cutout" not in self._pedb.stackup.all_layers:
                 self._pedb.stackup.add_document_layer(name="pyedb_cutout")
                 self._pedb.modeler.create_polygon(polygon_points, layer_name="pyedb_cutout", net_name="pyedb_cutout")
 
@@ -92,4 +94,8 @@ class CfgOperations(CfgBase):
 
     def get_data_from_db(self):
         self.op_cutout = CfgCutout(self._pedb)
-        return {"cutout": self.op_cutout.get_data_from_db()}
+        data_from_db = self.op_cutout.get_data_from_db()
+        if data_from_db:
+            return {"cutout": data_from_db}
+        else:
+            return {}

pyedb/configuration/cfg_padstacks.py

@@ -20,110 +20,87 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-
-from enum import Enum
+from pyedb.configuration.cfg_common import CfgBase
 
 
 class CfgPadstacks:
     """Padstack data class."""
 
-    def __init__(self, pdata, padstack_dict=None):
-        self._pedb = pdata._pedb
+    def __init__(self, pedb, padstack_dict=None):
+        self._pedb = pedb
         self.definitions = []
         self.instances = []
-        self._padstack_dict = padstack_dict
-        if self._padstack_dict:
-            if self._padstack_dict.get("definitions", ""):
-                self._definitions_dict = self._padstack_dict.get("definitions", "")
-                self.definitions = [Definition(pdata, definition) for definition in self._definitions_dict]
-            if self._padstack_dict.get("instances", None):
-                self._instances_dict = self._padstack_dict.get("instances", "")
-                self.instances = [Instance(pdata, inst) for inst in self._instances_dict]
+        if padstack_dict:
+            for pdef in padstack_dict.get("definitions", []):
+                self.definitions.append(Definition(**pdef))
+            for inst in padstack_dict.get("instances", []):
+                self.instances.append(Instance(**inst))
 
     def apply(self):
         """Apply padstack definition and instances on layout."""
-        for definition in self.definitions:
-            definition.apply()
-        for instance in self.instances:
-            instance.apply()
+        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())
+        if self.instances:
+            instances_layout = self._pedb.padstacks.instances_by_name
+            for inst in self.instances:
+                inst_layout = instances_layout[inst.name]
+                if inst.definition:
+                    # inst_layout.padstack_definition = inst.definition
+                    # Not supported by EDB API
+                    pass
+                if inst.backdrill_parameters:
+                    inst_layout.backdrill_parameters = inst.backdrill_parameters
+
+    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
+
+        instances_layout = self._pedb.padstacks.instances_by_name
+        for name, obj in instances_layout.items():
+            self.instances.append(
+                Instance(name=name, definition=obj.padstack_definition, backdrill_parameters=obj.backdrill_parameters)
+            )
+        instances = []
+        for i in self.instances:
+            instances.append(i.get_attributes())
+        data["instances"] = instances
+        return data
 
 
-class Definition:
+class Definition(CfgBase):
     """Padstack definition data class."""
 
-    def __init__(self, pdata, definition_dict):
-        self._pedb = pdata._pedb
-        self._definition_dict = definition_dict
-        self.name = self._definition_dict.get("name", None)
-        self.hole_diameter = self._definition_dict.get("hole_diameter", None)
-        self.hole_plating_thickness = self._definition_dict.get("hole_plating_thickness", None)
-        self.hole_material = self._definition_dict.get("hole_material", None)
-        self.hole_range = self._definition_dict.get("hole_range", None)
-
-    def apply(self):
-        """Apply padstack definition on layout."""
-        padstack_defs = self._pedb.padstacks.definitions
-        pdef = padstack_defs[self.name]
-        if self.hole_diameter:
-            pdef.hole_diameter = self.hole_diameter
-        if self.hole_plating_thickness:
-            pdef.hole_plating_thickness = self.hole_plating_thickness
-        if self.hole_material:
-            pdef.material = self.hole_material
-        if self.hole_range:
-            pdef.hole_range = self.hole_range
+    def __init__(self, **kwargs):
+        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)
 
 
-class Instance:
+class Instance(CfgBase):
     """Instance data class."""
 
-    def __init__(self, pdata, instances_dict):
-        self._pedb = pdata._pedb
-        self._instances_dict = instances_dict
-        self.name = self._instances_dict.get("name", "")
-        self.backdrill_top = None
-        self.backdrill_bottom = None
-        self._update_backdrill()
-
-    def _update_backdrill(self):
-        if "backdrill_top" in self._instances_dict:
-            self.backdrill_top = self.BackDrill()
-            self.backdrill_top.type = self.backdrill_top.BackDrillType.TOP
-            backdrill_top_dict = self._instances_dict["backdrill_top"]
-            self.backdrill_top.drill_to_layer = backdrill_top_dict.get("drill_to_layer", "")
-            self.backdrill_top.drill_diameter = backdrill_top_dict.get("drill_diameter", "")
-            self.backdrill_top.stub_length = backdrill_top_dict.get("stub_length", "")
-        if "backdrill_bottom" in self._instances_dict:
-            self.backdrill_bottom = self.BackDrill()
-            backdrill_bottom_dict = self._instances_dict["backdrill_bottom"]
-            self.backdrill_bottom.drill_to_layer = backdrill_bottom_dict.get("drill_to_layer", "")
-            self.backdrill_bottom.drill_diameter = backdrill_bottom_dict.get("drill_diameter", "")
-            self.backdrill_bottom.stub_length = backdrill_bottom_dict.get("stub_length", "")
-
-    class BackDrill:
-        """Backdrill data class."""
-
-        def __init__(self):
-            self.type = self.BackDrillType.BOTTOM
-            self.drill_to_layer = ""
-            self.drill_diameter = ""
-            self.stub_length = ""
-
-        class BackDrillType(Enum):
-            TOP = 0
-            BOTTOM = 1
-
-    def apply(self):
-        """Apply padstack instance on layout."""
-        padstack_instances = self._pedb.padstacks.instances_by_name
-        inst = padstack_instances[self.name]
-        if self.backdrill_top:
-            inst.set_backdrill_top(
-                self.backdrill_top.drill_to_layer, self.backdrill_top.drill_diameter, self.backdrill_top.stub_length
-            )
-        if self.backdrill_bottom:
-            inst.set_backdrill_bottom(
-                self.backdrill_bottom.drill_to_layer,
-                self.backdrill_bottom.drill_diameter,
-                self.backdrill_bottom.stub_length,
-            )
+    def __init__(self, **kwargs):
+        self.name = kwargs["name"]
+        self.definition = kwargs.get("definition", None)
+        self.backdrill_parameters = kwargs.get("backdrill_parameters", None)

pyedb/configuration/cfg_pin_groups.py

@@ -36,12 +36,14 @@ class CfgPinGroups:
 
     def get_data_from_db(self):
         self.pin_groups = []
-        for name, pg in self._pedb.siwave.pin_groups.items():
-            pins = [p.aedt_name for p in pg.pins.values()]
+        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=name,
-                reference_designator=None,
+                name=pg_name,
+                reference_designator=refdes,
                 pins=pins,
             )
             self.pin_groups.append(cfg_pg)
@@ -65,10 +67,7 @@ class CfgPinGroup(CfgBase):
     def create(self):
         """Apply pin group on layout."""
         if self.pins:
-            if self.reference_designator is None:
-                self._pedb.modeler.create_pin_group(self.name, pins_by_aedt_name=self.pins)
-            else:
-                self._pedb.siwave.create_pin_group(self.reference_designator, list(self.pins), self.name)
+            self._pedb.siwave.create_pin_group(self.reference_designator, list(self.pins), self.name)
         elif self.net:
             if self.reference_designator in self._pedb.components.instances:
                 comp = self._pedb.components.instances[self.reference_designator]