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

pyedb/configuration/configuration.py

@@ -33,8 +33,331 @@ from pyedb.dotnet.database.definition.package_def import PackageDef
 class Configuration:
     """Enables export and import of a JSON configuration file that can be applied to a new or existing design."""
 
+    class Grpc:
+        def __init__(self, parent):
+            self.parent = parent
+            self._pedb = parent._pedb
+
+        def configuration_stackup(self, kwargs):
+            if kwargs.get("fix_padstack_def"):
+                from pyedb.configuration.cfg_padstacks import CfgPadstackDefinition
+
+                pedb_defs = self._pedb.padstacks.definitions
+                temp = []
+                for _, pdef in pedb_defs.items():
+                    cfg_def = CfgPadstackDefinition(self._pedb, pdef)
+                    cfg_def.api.retrieve_parameters_from_edb()
+                    temp.append(cfg_def)
+                self.parent.cfg_data.stackup.apply()
+                for cfg_pdef in temp:
+                    cfg_pdef.api.set_parameters_to_edb()
+            else:
+                temp_pdef_data = {}
+                from ansys.edb.core.definition.padstack_def_data import (
+                    PadType as GrpcPadType,
+                )
+
+                for pdef_name, pdef in self._pedb.padstacks.definitions.items():
+                    for layer in pdef.data.layer_names:
+                        result = pdef.data.get_pad_parameters(layer, GrpcPadType.REGULAR_PAD)
+                        if len(result) == 4:
+                            # polygon based
+                            temp_pdef_data[pdef_name] = pdef.data
+                            break
+                self.parent.cfg_data.stackup.apply()
+                for pdef_name, pdef_data in temp_pdef_data.items():
+                    pdef = self._pedb.padstacks.definitions[pdef_name]
+                    pdef._padstack_def_data = pdef_data
+
+        def _load_stackup(self):
+            """Imports stackup information from json."""
+            data = self.data["stackup"]
+            materials = data.get("materials")
+
+            if materials:
+                edb_materials = {i.lower(): i for i, _ in self._pedb.materials.materials.items()}
+                for mat in materials:
+                    name = mat["name"].lower()
+                    if name in edb_materials:
+                        self._pedb.materials.delete_material(edb_materials[name])
+                for mat in materials:
+                    self._pedb.materials.add_material(**mat)
+
+            layers = data.get("layers")
+
+            if layers:
+                input_signal_layers = [i for i in layers if i["type"].lower() == "signal"]
+                if not len(input_signal_layers) == len(self._pedb.stackup.signal_layers):
+                    self._pedb.logger.error("Input signal layer count do not match.")
+                    return False
+
+                removal_list = []
+                lc_signal_layers = []
+                for name, obj in self._pedb.stackup.all_layers.items():
+                    if obj.type == "dielectric":
+                        removal_list.append(name)
+                    elif obj.type == "signal":
+                        lc_signal_layers.append(obj.id)
+                for l in removal_list:
+                    self._pedb.stackup.remove_layer(l)
+
+                # update all signal layers
+                id_name = {i[0]: i[1] for i in self._pedb.stackup.layers_by_id}
+                signal_idx = 0
+                for l in layers:
+                    if l["type"] == "signal":
+                        layer_id = lc_signal_layers[signal_idx]
+                        layer_name = id_name[layer_id]
+                        self._pedb.stackup.layers[layer_name].update(**l)
+                        signal_idx = signal_idx + 1
+
+                # add all dielectric layers. Dielectric layers must be added last. Otherwise,
+                # dielectric layer will occupy signal and document layer id.
+                prev_layer_clone = None
+                l = layers.pop(0)
+                if l["type"] == "signal":
+                    prev_layer_clone = self._pedb.stackup.layers[l["name"]]
+                else:
+                    prev_layer_clone = self._pedb.stackup.add_layer_top(**l)
+                for idx, l in enumerate(layers):
+                    if l["type"] == "dielectric":
+                        prev_layer_clone = self._pedb.stackup.add_layer_below(
+                            base_layer_name=prev_layer_clone.name, **l
+                        )
+                    elif l["type"] == "signal":
+                        prev_layer_clone = self._pedb.stackup.layers[l["name"]]
+
+        def _load_package_def(self):
+            """Imports package definition information from JSON."""
+            comps = self._pedb.components.instances
+            for pkgd in self.parent.data["package_definitions"]:
+                name = pkgd["name"]
+                if name in self._pedb.definitions.package:
+                    self._pedb.definitions.package[name].delete()
+                extent_bounding_box = pkgd.get("extent_bounding_box", None)
+                if extent_bounding_box:
+                    package_def = PackageDef(self._pedb, name=name, extent_bounding_box=extent_bounding_box)
+                else:
+                    package_def = PackageDef(self._pedb, name=name, component_part_name=pkgd["component_definition"])
+                package_def.maximum_power = pkgd["maximum_power"]
+                package_def.therm_cond = pkgd["therm_cond"]
+                package_def.theta_jb = pkgd["theta_jb"]
+                package_def.theta_jc = pkgd["theta_jc"]
+                package_def.height = pkgd["height"]
+
+                heatsink = pkgd.get("heatsink", None)
+                if heatsink:
+                    package_def.set_heatsink(
+                        heatsink["fin_base_height"],
+                        heatsink["fin_height"],
+                        heatsink["fin_orientation"],
+                        heatsink["fin_spacing"],
+                        heatsink["fin_thickness"],
+                    )
+
+                comp_def_name = pkgd["component_definition"]
+                comp_def = self._pedb.definitions.component[comp_def_name]
+
+                comp_list = dict()
+                if pkgd["apply_to_all"]:
+                    comp_list.update(
+                        {
+                            refdes: comp
+                            for refdes, comp in comp_def.components.items()
+                            if refdes not in pkgd["components"]
+                        }
+                    )
+                else:
+                    comp_list.update(
+                        {refdes: comp for refdes, comp in comp_def.components.items() if refdes in pkgd["components"]}
+                    )
+                for _, i in comp_list.items():
+                    i.package_def = name
+
+        def get_data_from_db(self, **kwargs):
+            """Get configuration data from layout.
+
+            Parameters
+            ----------
+            stackup
+
+            Returns
+            -------
+
+            """
+            self._pedb.logger.info("Getting data from layout database.")
+            data = {}
+            if kwargs.get("general", False):
+                data["general"] = self.parent.cfg_data.general.get_data_from_db()
+            if kwargs.get("stackup", False):
+                data["stackup"] = self.parent.cfg_data.stackup.get_data_from_db()
+            if kwargs.get("package_definitions", False):
+                data["package_definitions"] = self.parent.cfg_data.package_definitions.get_data_from_db()
+            if kwargs.get("setups", False):
+                setups = self.parent.cfg_data.setups
+                setups.retrieve_parameters_from_edb()
+                data["setups"] = setups.to_dict()
+            if kwargs.get("sources", False):
+                data["sources"] = self.parent.cfg_data.sources.get_data_from_db()
+            if kwargs.get("ports", False):
+                data["ports"] = self.parent.cfg_data.ports.get_data_from_db()
+            if kwargs.get("components", False) or kwargs.get("s_parameters", False):
+                self.parent.cfg_data.components.retrieve_parameters_from_edb()
+                components = []
+                for i in self.parent.cfg_data.components.components:
+                    components.append(i.get_attributes())
+
+                if kwargs.get("components", False):
+                    data["components"] = components
+                elif kwargs.get("s_parameters", False):
+                    data["s_parameters"] = self.parent.cfg_data.s_parameters.get_data_from_db(components)
+            if kwargs.get("nets", False):
+                data["nets"] = self.parent.cfg_data.nets.get_data_from_db()
+            if kwargs.get("pin_groups", False):
+                data["pin_groups"] = self.parent.cfg_data.pin_groups.get_data_from_db()
+            if kwargs.get("operations", False):
+                data["operations"] = self.parent.cfg_data.operations.get_data_from_db()
+            if kwargs.get("padstacks", False):
+                self.parent.cfg_data.padstacks.retrieve_parameters_from_edb()
+                definitions = []
+                for i in self.parent.cfg_data.padstacks.definitions:
+                    definitions.append(i.get_attributes())
+                instances = []
+                for i in self.parent.cfg_data.padstacks.instances:
+                    instances.append(i.get_attributes())
+                data["padstacks"] = dict()
+                data["padstacks"]["definitions"] = definitions
+                data["padstacks"]["instances"] = instances
+
+            if kwargs.get("boundaries", False):
+                data["boundaries"] = self.parent.cfg_data.boundaries.get_data_from_db()
+
+            return data
+
+        def export(
+            self,
+            file_path,
+            stackup=True,
+            package_definitions=False,
+            setups=True,
+            sources=True,
+            ports=True,
+            nets=True,
+            pin_groups=True,
+            operations=True,
+            components=True,
+            boundaries=True,
+            s_parameters=True,
+            padstacks=True,
+            general=True,
+        ):
+            """Export the configuration data from layout to a file.
+
+            Parameters
+            ----------
+            file_path : str, Path
+                File path to export the configuration data.
+            stackup : bool
+                Whether to export stackup or not.
+            package_definitions : bool
+                Whether to export package definitions or not.
+            setups : bool
+                Whether to export setups or not.
+            sources : bool
+                Whether to export sources or not.
+            ports : bool
+                Whether to export ports or not.
+            nets : bool
+                Whether to export nets.
+            pin_groups : bool
+                Whether to export pin groups.
+            operations : bool
+                Whether to export operations.
+            components : bool
+                Whether to export component.
+            boundaries : bool
+                Whether to export boundaries.
+            s_parameters : bool
+                Whether to export s_parameters.
+            padstacks : bool
+                Whether to export padstacks.
+            general : bool
+                Whether to export general information.
+            Returns
+            -------
+            bool
+            """
+            data = self.get_data_from_db(
+                stackup=stackup,
+                package_definitions=package_definitions,
+                setups=setups,
+                sources=sources,
+                ports=ports,
+                nets=nets,
+                pin_groups=pin_groups,
+                operations=operations,
+                components=components,
+                boundaries=boundaries,
+                s_parameters=s_parameters,
+                padstacks=padstacks,
+                general=general,
+            )
+
+            file_path = file_path if isinstance(file_path, Path) else Path(file_path)
+            file_path = file_path.with_suffix(".json") if file_path.suffix == "" else file_path
+
+            with open(file_path, "w") as f:
+                if file_path.suffix == ".json":
+                    json.dump(data, f, ensure_ascii=False, indent=4)
+                else:
+                    toml.dump(data, f)
+            return True if os.path.isfile(file_path) else False
+
+    class DotNet(Grpc):
+        def __init__(self, parent):
+            super().__init__(parent)
+
+        def configuration_stackup(self, kwargs):
+            if kwargs.get("fix_padstack_def"):
+                from pyedb.configuration.cfg_padstacks import CfgPadstackDefinition
+
+                pedb_defs = self._pedb.padstacks.definitions
+                temp = []
+                for _, pdef in pedb_defs.items():
+                    cfg_def = CfgPadstackDefinition(self._pedb, pdef)
+                    cfg_def.api.retrieve_parameters_from_edb()
+                    temp.append(cfg_def)
+                self.parent.cfg_data.stackup.apply()
+                for cfg_pdef in temp:
+                    cfg_pdef.api.set_parameters_to_edb()
+            else:
+                temp_pdef_data = {}
+                for pdef_name, pdef in self._pedb.padstacks.definitions.items():
+                    pdef_data = pdef._padstack_def_data
+                    for lyr_name in list(pdef_data.GetLayerNames()):
+                        result = pdef_data.GetPadParametersValue(
+                            lyr_name, self._pedb._edb.Definition.PadType.RegularPad
+                        )
+                        flag, pad_shape, params, offset_x, offset_y, rotation = result
+                        if flag is False:
+                            result = pdef_data.GetPolygonalPadParameters(
+                                lyr_name, self._pedb._edb.Definition.PadType.RegularPad
+                            )
+                            flag, polygon_data, offset_x, offset_y, rotation = result
+                            if flag:
+                                temp_pdef_data[pdef_name] = pdef_data
+                                break
+                self.parent.cfg_data.stackup.apply()
+                for pdef_name, pdef_data in temp_pdef_data.items():
+                    pdef = self._pedb.padstacks.definitions[pdef_name]
+                    pdef._padstack_def_data = pdef_data
+
     def __init__(self, pedb):
         self._pedb = pedb
+        if self._pedb.grpc:
+            self.api = self.Grpc(self)
+        else:
+            self.api = self.DotNet(self)
         self._components = self._pedb.components.instances
         self.data = {}
         self._s_parameter_library = ""
@@ -133,52 +456,7 @@ class Configuration:
         self.cfg_data.setups.apply()
 
         # Configure stackup
-        if kwargs.get("fix_padstack_def"):
-            from pyedb.configuration.cfg_padstacks import CfgPadstackDefinition
-
-            pedb_defs = self._pedb.padstacks.definitions
-            temp = []
-            for _, pdef in pedb_defs.items():
-                cfg_def = CfgPadstackDefinition(self._pedb, pdef)
-                cfg_def.api.retrieve_parameters_from_edb()
-                temp.append(cfg_def)
-            self.cfg_data.stackup.apply()
-            for cfg_pdef in temp:
-                cfg_pdef.api.set_parameters_to_edb()
-        else:
-            temp_pdef_data = {}
-            if self._pedb.grpc:
-                from ansys.edb.core.definition.padstack_def_data import (
-                    PadType as GrpcPadType,
-                )
-
-                for pdef_name, pdef in self._pedb.padstacks.definitions.items():
-                    for layer in pdef.data.layer_names:
-                        result = pdef.data.get_pad_parameters(layer, GrpcPadType.REGULAR_PAD)
-                        if len(result) == 4:
-                            # polygon based
-                            temp_pdef_data[pdef_name] = pdef.data
-                            break
-            else:
-                for pdef_name, pdef in self._pedb.padstacks.definitions.items():
-                    pdef_data = pdef._padstack_def_data
-                    for lyr_name in list(pdef_data.GetLayerNames()):
-                        result = pdef_data.GetPadParametersValue(
-                            lyr_name, self._pedb._edb.Definition.PadType.RegularPad
-                        )
-                        flag, pad_shape, params, offset_x, offset_y, rotation = result
-                        if flag is False:
-                            result = pdef_data.GetPolygonalPadParameters(
-                                lyr_name, self._pedb._edb.Definition.PadType.RegularPad
-                            )
-                            flag, polygon_data, offset_x, offset_y, rotation = result
-                            if flag:
-                                temp_pdef_data[pdef_name] = pdef_data
-                                break
-            self.cfg_data.stackup.apply()
-            for pdef_name, pdef_data in temp_pdef_data.items():
-                pdef = self._pedb.padstacks.definitions[pdef_name]
-                pdef._padstack_def_data = pdef_data
+        self.api.configuration_stackup(kwargs)
 
         # Configure padstacks
         if self.cfg_data.padstacks:
@@ -210,102 +488,11 @@ class Configuration:
 
     def _load_stackup(self):
         """Imports stackup information from json."""
-        data = self.data["stackup"]
-        materials = data.get("materials")
-
-        if materials:
-            edb_materials = {i.lower(): i for i, _ in self._pedb.materials.materials.items()}
-            for mat in materials:
-                name = mat["name"].lower()
-                if name in edb_materials:
-                    self._pedb.materials.delete_material(edb_materials[name])
-            for mat in materials:
-                self._pedb.materials.add_material(**mat)
-
-        layers = data.get("layers")
-
-        if layers:
-            input_signal_layers = [i for i in layers if i["type"].lower() == "signal"]
-            if not len(input_signal_layers) == len(self._pedb.stackup.signal_layers):
-                self._pedb.logger.error("Input signal layer count do not match.")
-                return False
-
-            removal_list = []
-            lc_signal_layers = []
-            for name, obj in self._pedb.stackup.all_layers.items():
-                if obj.type == "dielectric":
-                    removal_list.append(name)
-                elif obj.type == "signal":
-                    lc_signal_layers.append(obj.id)
-            for l in removal_list:
-                self._pedb.stackup.remove_layer(l)
-
-            # update all signal layers
-            id_name = {i[0]: i[1] for i in self._pedb.stackup.layers_by_id}
-            signal_idx = 0
-            for l in layers:
-                if l["type"] == "signal":
-                    layer_id = lc_signal_layers[signal_idx]
-                    layer_name = id_name[layer_id]
-                    self._pedb.stackup.layers[layer_name].update(**l)
-                    signal_idx = signal_idx + 1
-
-            # add all dielectric layers. Dielectric layers must be added last. Otherwise,
-            # dielectric layer will occupy signal and document layer id.
-            prev_layer_clone = None
-            l = layers.pop(0)
-            if l["type"] == "signal":
-                prev_layer_clone = self._pedb.stackup.layers[l["name"]]
-            else:
-                prev_layer_clone = self._pedb.stackup.add_layer_top(**l)
-            for idx, l in enumerate(layers):
-                if l["type"] == "dielectric":
-                    prev_layer_clone = self._pedb.stackup.add_layer_below(base_layer_name=prev_layer_clone.name, **l)
-                elif l["type"] == "signal":
-                    prev_layer_clone = self._pedb.stackup.layers[l["name"]]
+        self.api._load_stackup()
 
     def _load_package_def(self):
         """Imports package definition information from JSON."""
-        comps = self._pedb.components.instances
-        for pkgd in self.data["package_definitions"]:
-            name = pkgd["name"]
-            if name in self._pedb.definitions.package:
-                self._pedb.definitions.package[name].delete()
-            extent_bounding_box = pkgd.get("extent_bounding_box", None)
-            if extent_bounding_box:
-                package_def = PackageDef(self._pedb, name=name, extent_bounding_box=extent_bounding_box)
-            else:
-                package_def = PackageDef(self._pedb, name=name, component_part_name=pkgd["component_definition"])
-            package_def.maximum_power = pkgd["maximum_power"]
-            package_def.therm_cond = pkgd["therm_cond"]
-            package_def.theta_jb = pkgd["theta_jb"]
-            package_def.theta_jc = pkgd["theta_jc"]
-            package_def.height = pkgd["height"]
-
-            heatsink = pkgd.get("heatsink", None)
-            if heatsink:
-                package_def.set_heatsink(
-                    heatsink["fin_base_height"],
-                    heatsink["fin_height"],
-                    heatsink["fin_orientation"],
-                    heatsink["fin_spacing"],
-                    heatsink["fin_thickness"],
-                )
-
-            comp_def_name = pkgd["component_definition"]
-            comp_def = self._pedb.definitions.component[comp_def_name]
-
-            comp_list = dict()
-            if pkgd["apply_to_all"]:
-                comp_list.update(
-                    {refdes: comp for refdes, comp in comp_def.components.items() if refdes not in pkgd["components"]}
-                )
-            else:
-                comp_list.update(
-                    {refdes: comp for refdes, comp in comp_def.components.items() if refdes in pkgd["components"]}
-                )
-            for _, i in comp_list.items():
-                i.package_def = name
+        self.api._load_package_def()
 
     def get_data_from_db(self, **kwargs):
         """Get configuration data from layout.
@@ -318,52 +505,7 @@ class Configuration:
         -------
 
         """
-        self._pedb.logger.info("Getting data from layout database.")
-        data = {}
-        if kwargs.get("general", False):
-            data["general"] = self.cfg_data.general.get_data_from_db()
-        if kwargs.get("stackup", False):
-            data["stackup"] = self.cfg_data.stackup.get_data_from_db()
-        if kwargs.get("package_definitions", False):
-            data["package_definitions"] = self.cfg_data.package_definitions.get_data_from_db()
-        if kwargs.get("setups", False):
-            data["setups"] = self.cfg_data.setups.get_data_from_db()
-        if kwargs.get("sources", False):
-            data["sources"] = self.cfg_data.sources.get_data_from_db()
-        if kwargs.get("ports", False):
-            data["ports"] = self.cfg_data.ports.get_data_from_db()
-        if kwargs.get("components", False) or kwargs.get("s_parameters", False):
-            self.cfg_data.components.retrieve_parameters_from_edb()
-            components = []
-            for i in self.cfg_data.components.components:
-                components.append(i.get_attributes())
-
-            if kwargs.get("components", False):
-                data["components"] = components
-            elif kwargs.get("s_parameters", False):
-                data["s_parameters"] = self.cfg_data.s_parameters.get_data_from_db(components)
-        if kwargs.get("nets", False):
-            data["nets"] = self.cfg_data.nets.get_data_from_db()
-        if kwargs.get("pin_groups", False):
-            data["pin_groups"] = self.cfg_data.pin_groups.get_data_from_db()
-        if kwargs.get("operations", False):
-            data["operations"] = self.cfg_data.operations.get_data_from_db()
-        if kwargs.get("padstacks", False):
-            self.cfg_data.padstacks.retrieve_parameters_from_edb()
-            definitions = []
-            for i in self.cfg_data.padstacks.definitions:
-                definitions.append(i.get_attributes())
-            instances = []
-            for i in self.cfg_data.padstacks.instances:
-                instances.append(i.get_attributes())
-            data["padstacks"] = dict()
-            data["padstacks"]["definitions"] = definitions
-            data["padstacks"]["instances"] = instances
-
-        if kwargs.get("boundaries", False):
-            data["boundaries"] = self.cfg_data.boundaries.get_data_from_db()
-
-        return data
+        return self.api.get_data_from_db(**kwargs)
 
     def export(
         self,
@@ -418,28 +560,19 @@ class Configuration:
         -------
         bool
         """
-        data = self.get_data_from_db(
-            stackup=stackup,
-            package_definitions=package_definitions,
-            setups=setups,
-            sources=sources,
-            ports=ports,
-            nets=nets,
-            pin_groups=pin_groups,
-            operations=operations,
-            components=components,
-            boundaries=boundaries,
-            s_parameters=s_parameters,
-            padstacks=padstacks,
-            general=general,
+        return self.api.export(
+            file_path,
+            stackup=True,
+            package_definitions=False,
+            setups=True,
+            sources=True,
+            ports=True,
+            nets=True,
+            pin_groups=True,
+            operations=True,
+            components=True,
+            boundaries=True,
+            s_parameters=True,
+            padstacks=True,
+            general=True,
         )
-
-        file_path = file_path if isinstance(file_path, Path) else Path(file_path)
-        file_path = file_path.with_suffix(".json") if file_path.suffix == "" else file_path
-
-        with open(file_path, "w") as f:
-            if file_path.suffix == ".json":
-                json.dump(data, f, ensure_ascii=False, indent=4)
-            else:
-                toml.dump(data, f)
-        return True if os.path.isfile(file_path) else False

pyedb/dotnet/database/edb_data/design_options.py

@@ -19,6 +19,7 @@
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
+import warnings
 
 
 class EdbDesignOptions:
@@ -51,8 +52,25 @@ class EdbDesignOptions:
             ``True`` if antipad is always on, ``False`` otherwise.
 
         """
-        return self._active_cell.GetAntiPadsAlwaysOn()
+        warnings.warn("Use new property :func:`anti_pads_always_on` instead.", DeprecationWarning)
+        return self.anti_pads_always_on
 
     @antipads_always_on.setter
     def antipads_always_on(self, value):
+        self.anti_pads_always_on = value
+
+    @property
+    def anti_pads_always_on(self):
+        """Whether to always turn on antipad.
+
+        Returns
+        -------
+        bool
+            ``True`` if antipad is always on, ``False`` otherwise.
+
+        """
+        return self._active_cell.GetAntiPadsAlwaysOn()
+
+    @anti_pads_always_on.setter
+    def anti_pads_always_on(self, value):
         self._active_cell.SetAntiPadsAlwaysOn(value)

pyedb/dotnet/database/edb_data/padstacks_data.py

@@ -35,6 +35,7 @@ from pyedb.dotnet.database.general import (
     snake_to_pascal,
 )
 from pyedb.dotnet.database.geometry.polygon_data import PolygonData
+from pyedb.generic.data_handlers import float_units
 from pyedb.generic.general_methods import generate_unique_name
 from pyedb.modeler.geometry_operators import GeometryOperators
 
@@ -1958,15 +1959,18 @@ class EDBPadstackInstance(Primitive):
         pad_shape = padstack_pad.geometry_type
         params = padstack_pad.parameters_values
         polygon_data = padstack_pad._polygon_data_dotnet
+        pad_offset = [float_units(padstack_pad.offset_x), float_units(padstack_pad.offset_y)]
 
         def _rotate(p):
             x = p[0] * math.cos(rotation) - p[1] * math.sin(rotation)
             y = p[0] * math.sin(rotation) + p[1] * math.cos(rotation)
             return [x, y]
 
-        def _translate(p):
-            x = p[0] + padstack_center[0]
-            y = p[1] + padstack_center[1]
+        def _translate(p, t=None):
+            if t is None:
+                t = padstack_center
+            x = p[0] + t[0]
+            y = p[1] + t[1]
             return [x, y]
 
         rect = None
@@ -2092,7 +2096,8 @@ class EDBPadstackInstance(Primitive):
 
         if rect is None or len(rect) != 4:
             return False
-        path = self._pedb.modeler.Shape("polygon", points=rect)
+        offset_rect = [_translate(p, _rotate(pad_offset)) for p in rect]
+        path = self._pedb.modeler.Shape("polygon", points=offset_rect)
         pdata = self._pedb.modeler.shape_to_polygon_data(path)
         new_rect = []
         for point in pdata.Points:
@@ -2142,7 +2147,7 @@ class EDBPadstackInstance(Primitive):
             component_only=component_only,
         )
 
-    def split(self):
+    def split(self) -> list:
         """Split padstack instance into multiple instances. The new instances only connect adjacent layers."""
         pdef_name = self.padstack_definition
         position = self.position
@@ -2151,11 +2156,16 @@ class EDBPadstackInstance(Primitive):
         stackup_layer_range = list(self._pedb.stackup.signal_layers.keys())
         start_idx = stackup_layer_range.index(self.start_layer)
         stop_idx = stackup_layer_range.index(self.stop_layer)
+        temp = []
         for idx, (l1, l2) in enumerate(
             list(zip(stackup_layer_range[start_idx:stop_idx], stackup_layer_range[start_idx + 1 : stop_idx + 1]))
         ):
-            self._pedb.padstacks.place(position, pdef_name, net_name, f"{name}_{idx}", fromlayer=l1, tolayer=l2)
+            pd_inst = self._pedb.padstacks.place(
+                position, pdef_name, net_name, f"{name}_{idx}", fromlayer=l1, tolayer=l2
+            )
+            temp.append(pd_inst)
         self.delete()
+        return temp
 
     def convert_hole_to_conical_shape(self, angle=75):
         """Convert actual padstack instance to microvias 3D Objects with a given aspect ratio.