pyedb 0.10.dev0__tar.gz → 0.11.0__tar.gz

{pyedb-0.10.dev0 → pyedb-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyedb
-Version: 0.10.dev0
+Version: 0.11.0
 Summary: Higher-Level Pythonic Ansys Electronics Data Base
 Author-email: "ANSYS, Inc." <pyansys.core@ansys.com>
 Maintainer-email: PyEDB developers <simon.vandenbrouck@ansys.com>
@@ -22,7 +22,7 @@ Requires-Dist: dotnetcore2 ==3.1.23;platform_system=='Linux'
 Requires-Dist: pydantic>=2.6.4,<2.8
 Requires-Dist: toml == 0.10.2
 Requires-Dist: Rtree >= 1.2.0
-Requires-Dist: ansys-sphinx-theme>=0.10.0,<0.16 ; extra == "doc"
+Requires-Dist: ansys-sphinx-theme>=0.10.0,<0.17 ; extra == "doc"
 Requires-Dist: imageio>=2.30.0,<2.35 ; extra == "doc"
 Requires-Dist: ipython>=8.13.0,<8.25 ; extra == "doc"
 Requires-Dist: jupyterlab>=4.0.0,<4.3 ; extra == "doc"

{pyedb-0.10.dev0 → pyedb-0.11.0}/pyproject.toml

@@ -45,7 +45,7 @@ tests = [
     "pytest-xdist>=3.5.0,<3.7",
 ]
 doc = [
-    "ansys-sphinx-theme>=0.10.0,<0.16",
+    "ansys-sphinx-theme>=0.10.0,<0.17",
     "imageio>=2.30.0,<2.35",
     "ipython>=8.13.0,<8.25",
     "jupyterlab>=4.0.0,<4.3",

{pyedb-0.10.dev0 → pyedb-0.11.0}/src/pyedb/__init__.py

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

pyedb-0.11.0/src/pyedb/configuration/cfg_boundaries.py

@@ -0,0 +1,115 @@
+# Copyright (C) 2023 - 2024 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+
+from enum import Enum
+
+
+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", True)
+        self._map_open_region_type()
+        self.pml_visible = self._boundaries_dict.get("pml_visible", False)
+        self.pml_operation_frequency = self._boundaries_dict.get("pml_operation_frequency", "5GHz")
+        self.pml_radiation_factor = self._boundaries_dict.get("pml_radiation_factor", 10)
+        self._map_dielectric_extend_type()
+        self.dielectric_base_polygon = self._boundaries_dict.get("dielectric_base_polygon", "")
+        self.horizontal_padding = self._boundaries_dict.get("horizontal_padding", 0.0)
+        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", "")
+        self.air_box_truncate_model_ground_layers = self._boundaries_dict.get(
+            "air_box_truncate_model_ground_layers", False
+        )
+        self.air_box_horizontal_padding = self._boundaries_dict.get("air_box_horizontal_padding", 0.15)
+        self.air_box_positive_vertical_padding = self._boundaries_dict.get("air_box_positive_vertical_padding", 1)
+        self.air_box_negative_vertical_padding = self._boundaries_dict.get("air_box_negative_vertical_padding", 1)
+
+    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
+
+    def apply(self):
+        """Imports boundary information from JSON."""
+        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()
+        self._pedb.hfss.hfss_extent_info.is_pml_visible = self.pml_visible
+        self._pedb.hfss.hfss_extent_info.operating_freq = self.pml_operation_frequency
+        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
+        self._pedb.hfss.hfss_extent_info.dielectric_extent_size = float(self.horizontal_padding)
+        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()
+        self._pedb.hfss.hfss_extent_info.truncate_air_box_at_ground = self.air_box_truncate_model_ground_layers
+        self._pedb.hfss.hfss_extent_info.air_box_horizontal_extent = float(self.air_box_horizontal_padding)
+        self._pedb.hfss.hfss_extent_info.air_box_positive_vertical_extent = float(
+            self.air_box_positive_vertical_padding
+        )
+        self._pedb.hfss.hfss_extent_info.air_box_negative_vertical_extent = float(
+            self.air_box_negative_vertical_padding
+        )

pyedb-0.11.0/src/pyedb/configuration/cfg_components.py

@@ -0,0 +1,205 @@
+# Copyright (C) 2023 - 2024 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+
+from enum import Enum
+
+
+class CfgRlcModel:
+    def __init__(self):
+        self.resistance = 0.0
+        self.inductance = 0.0
+        self.capacitance = 0.0
+        self.rlc_model_type = self.RlcModelType.SERIES
+        self.enabled = False
+        self.pin_pairs = []
+
+    class RlcModelType(Enum):
+        SERIES = 0
+        PARALLEL = 1
+
+
+class CfgPortProperties:
+    def __init__(self):
+        self.ref_offset = 0.0
+        self.ref_size_auto = True
+        self.ref_size_x = 0.0
+        self.ref_size_y = 0.0
+
+
+class CfgSolderBallsProperties:
+    def __init__(self):
+        self.shape = self.Shape.CYLINDER
+        self.diameter = 0.0
+        self.mid_diameter = 0.0
+        self.height = 0.0
+        self.enable = True
+
+    class Shape(Enum):
+        CYLINDER = 0
+        SPHEROID = 1
+
+
+class CfgComponent:
+    def __init__(self, pdata, **kwargs):
+        self._pedb = pdata.pedb
+        self._comp_dict = kwargs
+        self.reference_designator = ""
+        self.part_type = self.ComponentType.RESISTOR
+        self.enabled = True
+        self.rlc_model = CfgRlcModel()
+        self.port_properties = CfgPortProperties()
+        self.solder_balls = CfgSolderBallsProperties()
+        self._update()
+        self.layout_comp = None
+
+    class ComponentType(Enum):
+        RESISTOR = 0
+        INDUCTOR = 1
+        CAPACITOR = 2
+        IO = 3
+        IC = 4
+        OTHER = 5
+
+    def _update(self):
+        self.reference_designator = self._comp_dict.get("reference_designator")
+        self.enabled = self._comp_dict.get("enabled")
+        part_type = self._comp_dict["part_type"].lower()
+        if part_type == "resistor":
+            self.part_type = self.part_type.RESISTOR
+        elif part_type == "capacitor":
+            self.part_type = self.part_type.CAPACITOR
+        elif part_type == "inductor":
+            self.part_type = self.part_type.INDUCTOR
+        elif part_type == "io":
+            self.part_type = self.part_type.IO
+        elif part_type == "ic":
+            self.part_type = self.part_type.IC
+        else:
+            self.part_type = self.part_type.OTHER
+
+        if self.part_type.value in [0, 1, 2]:
+            rlc_model = self._comp_dict["rlc_model"] if "rlc_model" in self._comp_dict else None
+            if rlc_model:
+                pin_pairs = rlc_model["pin_pairs"] if "pin_pairs" in rlc_model else None
+                if pin_pairs:
+                    self.rlc_model.pin_pairs = []
+                    for pp in pin_pairs:
+                        if pp["type"] == "Parallel":
+                            self.rlc_model.rlc_model_type = self.rlc_model.rlc_model_type.PARALLEL
+
+                        self.rlc_model.pin_pairs.append([pp["p1"], pp["p2"]])
+                        self.rlc_model.resistance = pp["resistance"] if "resistance" in pp else None
+                        self.rlc_model.inductance = pp["inductance"] if "inductance" in pp else None
+                        self.rlc_model.capacitance = pp["capacitance"] if "capacitance" in pp else None
+
+        port_properties = self._comp_dict["port_properties"] if "port_properties" in self._comp_dict else None
+        if port_properties:
+            self.port_properties.ref_offset = float(port_properties["reference_offset"])
+            self.port_properties.ref_size_auto = bool(port_properties["reference_size_auto"])
+            self.port_properties.ref_size_x = float(port_properties["reference_size_x"])
+            self.port_properties.ref_size_y = float(port_properties["reference_size_y"])
+
+        solder_ball_properties = (
+            self._comp_dict["solder_ball_properties"] if "solder_ball_properties" in self._comp_dict else None
+        )
+        if solder_ball_properties:
+            if solder_ball_properties["shape"].lower() == "spheroid":
+                self.solder_balls.shape = self.solder_balls.shape.SPHEROID
+            self.solder_balls.diameter = solder_ball_properties["diameter"]
+            self.solder_balls.mid_diameter = (
+                float(solder_ball_properties["mid_diameter"])
+                if "mid_diameter" in solder_ball_properties
+                else self.solder_balls.diameter
+            )
+            self.solder_balls.height = solder_ball_properties["height"]
+
+    def apply(self):
+        """Apply component on layout."""
+        self.layout_comp = self._pedb.components[self.reference_designator]
+        if self.layout_comp:
+            self._apply_part_type()
+            if self.part_type.name in ["CAPACITOR", "RESISTOR", "INDUCTOR"]:
+                self._apply_rlc_model()
+            else:
+                self._apply_solder_balls()
+
+    def _apply_part_type(self):
+        if self.part_type.name == "CAPACITOR":
+            self.layout_comp.type = "Capacitor"
+        elif self.part_type.name == "RESISTOR":
+            self.layout_comp.type = "Resistor"
+        elif self.part_type.name == "INDUCTOR":
+            self.layout_comp.type = "Inductor"
+        elif self.part_type.name == "IC":
+            self.layout_comp.type = "IC"
+        elif self.part_type.name == "IO":
+            self.layout_comp.type = "IO"
+        elif self.part_type.name == "OTHER":
+            self.layout_comp.type = "Other"
+
+    def _apply_rlc_model(self):
+        if self.part_type.value in [0, 1, 2]:
+            self.layout_comp.is_enabled = self.enabled
+            if self.rlc_model:
+                model_layout = self.layout_comp.model
+                if self.rlc_model.pin_pairs:
+                    for pp in model_layout.pin_pairs:
+                        model_layout.delete_pin_pair_rlc(pp)
+                    for pp in self.rlc_model.pin_pairs:
+                        pin_pair = self._pedb.edb_api.utility.PinPair(pp[0], pp[1])
+                        rlc = self._pedb.edb_api.utility.Rlc()
+                        rlc.IsParallel = False if self.rlc_model.rlc_model_type.SERIES else True
+                        if not self.rlc_model.resistance is None:
+                            rlc.REnabled = True
+                            rlc.R = self._pedb.edb_value(self.rlc_model.resistance)
+                        else:
+                            rlc.REnabled = False
+                        if not self.rlc_model.inductance is None:
+                            rlc.LEnabled = True
+                            rlc.L = self._pedb.edb_value(self.rlc_model.inductance)
+                        else:
+                            rlc.LEnabled = False
+
+                        if not self.rlc_model.capacitance is None:
+                            rlc.CEnabled = True
+                            rlc.C = self._pedb.edb_value(self.rlc_model.capacitance)
+                        else:
+                            rlc.CEnabled = False
+                        model_layout._set_pin_pair_rlc(pin_pair, rlc)
+                        self.layout_comp.model = model_layout
+
+    def _apply_solder_balls(self):
+        if self.solder_balls.enable:
+            shape = "Cylinder"
+            if self.solder_balls.shape == self.solder_balls.shape.SPHEROID:
+                shape = "Spheroid"
+            self._pedb.components.set_solder_ball(
+                component=self.reference_designator,
+                sball_diam=self.solder_balls.diameter,
+                sball_mid_diam=self.solder_balls.mid_diameter,
+                sball_height=self.solder_balls.height,
+                shape=shape,
+                auto_reference_size=self.port_properties.ref_size_auto,
+                reference_height=self.port_properties.ref_offset,
+                reference_size_x=self.port_properties.ref_size_x,
+                reference_size_y=self.port_properties.ref_size_y,
+            )

pyedb-0.11.0/src/pyedb/configuration/cfg_data.py

@@ -0,0 +1,68 @@
+# Copyright (C) 2023 - 2024 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+
+from pyedb.configuration.cfg_boundaries import CfgBoundaries
+from pyedb.configuration.cfg_components import CfgComponent
+from pyedb.configuration.cfg_general import CfgGeneral
+from pyedb.configuration.cfg_nets import CfgNets
+from pyedb.configuration.cfg_padstacks import CfgPadstacks
+from pyedb.configuration.cfg_pin_groups import CfgPinGroup
+from pyedb.configuration.cfg_ports_sources import CfgPort, CfgSources
+from pyedb.configuration.cfg_s_parameter_models import CfgSParameterModel
+from pyedb.configuration.cfg_setup import CfgSetup
+from pyedb.configuration.cfg_spice_models import CfgSpiceModel
+
+
+class CfgData(object):
+    """Manages configure data."""
+
+    def __init__(self, pedb, **kwargs):
+        self.pedb = pedb
+        self.edb_comps = self.pedb.components.components
+        self.general = CfgGeneral(self, kwargs.get("general", None))
+        self.boundaries = {}
+        if kwargs.get("boundaries", None):
+            self.boundaries = CfgBoundaries(self, kwargs.get("boundaries", None))
+        self.nets = CfgNets(self)
+        if kwargs.get("nets"):
+            self.nets = CfgNets(
+                self, kwargs.get("nets", {}).get("signal_nets", []), kwargs.get("nets", {}).get("power_ground_nets", [])
+            )
+        self.components = [CfgComponent(self, **component) for component in kwargs.get("components", [])]
+        self.padstacks = CfgPadstacks(self, kwargs.get("padstacks", None))
+        self.pin_groups = [CfgPinGroup(self, pin_group) for pin_group in kwargs.get("pin_groups", [])]
+        self.ports = [CfgPort(self, **port) for port in kwargs.get("ports", [])]
+        self.sources = [CfgSources(self, **source) for source in kwargs.get("sources", [])]
+        self.setups = [CfgSetup(self)]
+        if kwargs.get("setups", None):
+            self.setups = [CfgSetup(self, setup) for setup in kwargs.get("setups", [])]
+        self.stackup = None
+        self.s_parameters = [
+            CfgSParameterModel(self, self.general.s_parameter_library, sparam_model)
+            for sparam_model in kwargs.get("s_parameters", [])
+        ]
+        self.spice_models = [
+            CfgSpiceModel(self, self.general.spice_model_library, spice_model)
+            for spice_model in kwargs.get("spice_models", [])
+        ]
+        self.package_definition = None
+        self.operations = None

pyedb-0.11.0/src/pyedb/configuration/cfg_general.py

@@ -0,0 +1,34 @@
+# Copyright (C) 2023 - 2024 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+
+
+class CfgGeneral:
+    """Manage configuration general settings."""
+
+    def __init__(self, pdata, general_dict):
+        self._pedb = pdata.pedb
+        self.spice_model_library = ""
+        self.s_parameter_library = ""
+        if general_dict:
+            self._general_dict = general_dict
+            self.spice_model_library = self._general_dict.get("spice_model_library", "")
+            self.s_parameter_library = self._general_dict.get("s_parameter_library", "")

pyedb-0.11.0/src/pyedb/configuration/cfg_nets.py

@@ -0,0 +1,43 @@
+# Copyright (C) 2023 - 2024 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+
+
+class CfgNets:
+    """Manage configuration net class."""
+
+    def __init__(self, pdata, signal_nets=None, power_nets=None):
+        self._pedb = pdata.pedb
+        self.signal_nets = []
+        self.power_nets = []
+        if signal_nets:
+            self.signal_nets = signal_nets
+        if power_nets:
+            self.power_nets = power_nets
+
+    def apply(self):
+        """Apply net on layout."""
+        for signal_net in self.signal_nets:
+            if signal_net in self._pedb.nets:
+                self._pedb.nets.nets[signal_net].is_power_ground = False
+        for power_net in self.power_nets:
+            if power_net in self._pedb.nets:
+                self._pedb.nets.nets[power_net].is_power_ground = True

pyedb-0.11.0/src/pyedb/configuration/cfg_padstacks.py

@@ -0,0 +1,125 @@
+# Copyright (C) 2023 - 2024 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# 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.
+
+
+from enum import Enum
+
+
+class CfgPadstacks:
+    """Padstack data class."""
+
+    def __init__(self, pdata, padstack_dict=None):
+        self._pedb = pdata.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]
+
+    def apply(self):
+        """Apply padstack definition and instances on layout."""
+        for definition in self.definitions:
+            definition.apply()
+        for instance in self.instances:
+            instance.apply()
+
+
+class Definition:
+    """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", "")
+        self.hole_diameter = self._definition_dict.get("hole_diameter", "")
+        self.hole_plating_thickness = self._definition_dict.get("hole_plating_thickness", "")
+        self.hole_material = self._definition_dict.get("hole_material", "")
+        self.hole_range = self._definition_dict.get("hole_range", "")
+
+    def apply(self):
+        """Apply padstack definition on layout."""
+        padstack_defs = self._pedb.padstacks.definitions
+        pdef = padstack_defs[self.name]
+        pdef.hole_diameter = self.hole_diameter
+        pdef.hole_plating_thickness = self.hole_plating_thickness
+        pdef.material = self.hole_material
+        pdef.hole_range = self.hole_range
+
+
+class Instance:
+    """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,
+            )