pyedb 0.15.dev0__tar.gz → 0.17.0__tar.gz

{pyedb-0.15.dev0 → pyedb-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyedb
-Version: 0.15.dev0
+Version: 0.17.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>

{pyedb-0.15.dev0 → pyedb-0.17.0}/src/pyedb/__init__.py

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

{pyedb-0.15.dev0 → pyedb-0.17.0}/src/pyedb/configuration/cfg_common.py

@@ -22,9 +22,7 @@
 
 
 class CfgBase:
-    @property
-    def protected_attributes(self):
-        return []
+    protected_attributes = []
 
     def get_attributes(self, exclude=None):
         attrs = {i: j for i, j in self.__dict__.items() if i not in self.protected_attributes}

{pyedb-0.15.dev0 → pyedb-0.17.0}/src/pyedb/configuration/cfg_components.py

@@ -51,10 +51,13 @@ 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
@@ -65,15 +68,34 @@ class CfgComponent(CfgBase):
 
         self.rlc_model = [CfgRlcModel(**rlc_m) for rlc_m in rlc_models]
 
-    @property
-    def protected_attributes(self):
-        return ["reference_designator"]
+        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
 
 
 class CfgComponents:
-    def __init__(self, pedb, data):
+    def __init__(self, pedb, components_data):
         self._pedb = pedb
-        self.components = [CfgComponent(**comp) for comp in data]
+        self.components = [CfgComponent(**comp) for comp in components_data]
 
     def apply(self):
         comps_in_db = self._pedb.components
@@ -129,3 +151,25 @@ class CfgComponents:
                         setattr(c_db, attr, value)
                     else:
                         raise AttributeError(f"'{attr}' is not valid component attribute.")
+
+    def _load_data_from_db(self):
+        self.components = []
+        comps_in_db = self._pedb.components
+        for _, comp in comps_in_db.components.items():
+            cfg_comp = CfgComponent(
+                enabled=comp.enabled,
+                reference_designator=comp.name,
+                part_type=comp.type,
+                value=comp.value,
+                definition=comp.component_def,
+                location=comp.location,
+                placement_layer=comp.placement_layer,
+            )
+            self.components.append(cfg_comp)
+
+    def get_data_from_db(self):
+        self._load_data_from_db()
+        data = []
+        for comp in self.components:
+            data.append(comp.export_properties())
+        return data

{pyedb-0.15.dev0 → pyedb-0.17.0}/src/pyedb/configuration/cfg_data.py

@@ -31,7 +31,7 @@ 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_setup import CfgSetups
 from pyedb.configuration.cfg_spice_models import CfgSpiceModel
 from pyedb.configuration.cfg_stackup import CfgStackup
 
@@ -54,8 +54,7 @@ class CfgData(object):
                 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.components = CfgComponents(self._pedb, data=kwargs.get("components", []))
+        self.components = CfgComponents(self._pedb, components_data=kwargs.get("components", []))
 
         self.padstacks = CfgPadstacks(self, kwargs.get("padstacks", None))
 
@@ -65,9 +64,7 @@ class CfgData(object):
 
         self.sources = [CfgSources(self, **source) for source in kwargs.get("sources", [])]
 
-        self.setups = []
-        if kwargs.get("setups", None):
-            self.setups = [CfgSetup(self, setup) for setup in kwargs.get("setups", [])]
+        self.setups = CfgSetups(self._pedb, setups_data=kwargs.get("setups", []))
 
         self.stackup = CfgStackup(self._pedb, data=kwargs.get("stackup", {}))
 

{pyedb-0.15.dev0 → pyedb-0.17.0}/src/pyedb/configuration/cfg_package_definition.py

@@ -27,6 +27,9 @@ from pyedb.dotnet.edb_core.definition.package_def import PackageDef
 class CfgPackage(CfgBase):
     """Configuration package class."""
 
+    # Attributes cannot be set to package definition class or don't exist in package definition class.
+    protected_attributes = ["apply_to_all", "components", "extent_bounding_box", "component_definition"]
+
     def __init__(self, **kwargs):
         self.name = kwargs.get("name", None)
         self.component_definition = kwargs.get("component_definition", None)
@@ -48,11 +51,6 @@ class CfgPackage(CfgBase):
     def heatsink(self, value):
         self._heatsink = value
 
-    @property
-    def protected_attributes(self):
-        """Attributes cannot be set to package definition class or don't exist in package definition class."""
-        return ["apply_to_all", "components", "extent_bounding_box", "component_definition"]
-
 
 class CfgHeatSink(CfgBase):
     """Configuration heat sink class."""

pyedb-0.17.0/src/pyedb/configuration/cfg_setup.py

@@ -0,0 +1,239 @@
+# 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_common import CfgBase
+
+
+class CfgFrequencies(CfgBase):
+    def __init__(self, **kwargs):
+        self.distribution = kwargs.get("distribution").replace(" ", "_") if kwargs.get("distribution") else None
+        self.start = kwargs.get("start")
+        self.stop = kwargs.get("stop")
+        self.increment = kwargs.get("increment", kwargs.get("points", kwargs.get("samples", kwargs.get("step"))))
+
+
+class CfgSweepData(CfgBase):
+    def __init__(self, **kwargs):
+        self.name = kwargs.get("name")
+        self.type = kwargs.get("type").lower() if kwargs.get("type") else None
+        self.frequencies = []
+        for kw in kwargs.get("frequencies", []):
+            self.frequencies.append(CfgFrequencies(**kw))
+
+
+class CfgSetup(CfgBase):
+    def __init__(self, pedb, **kwargs):
+        self._pedb = pedb
+        self.name = kwargs.get("name")
+        self.type = kwargs.get("type").lower() if kwargs.get("type") else None
+
+        self.freq_sweep = []
+        for i in kwargs.get("freq_sweep", []):
+            self.freq_sweep.append(CfgSweepData(**i))
+
+    def _apply_freq_sweep(self, edb_setup):
+        for i in self.freq_sweep:
+            f_set = []
+            kw = {}
+            for attr in i.get_attributes(exclude="name"):
+                if attr == "frequencies":
+                    for f in i.frequencies:
+                        f_set.append([f.distribution, f.start, f.stop, f.increment])
+                else:
+                    kw[attr] = getattr(i, attr)
+            edb_setup.add_sweep(i.name, frequency_set=f_set, **kw)
+
+
+class CfgSIwaveACSetup(CfgSetup):
+    def __init__(self, pedb, **kwargs):
+        super().__init__(pedb, **kwargs)
+        self.si_slider_position = kwargs.get("si_slider_position")
+        self.pi_slider_position = kwargs.get("pi_slider_position")
+
+    def apply(self):
+        if self.name in self._pedb.setups:
+            raise "Setup {} already existing. Editing it.".format(self.name)
+
+        kwargs = (
+            {"si_slider_position": self.si_slider_position}
+            if self.si_slider_position is not None
+            else {"pi_slider_position": self.pi_slider_position}
+        )
+
+        edb_setup = self._pedb.create_siwave_syz_setup(name=self.name, **kwargs)
+        self._apply_freq_sweep(edb_setup)
+
+
+class CfgSIwaveDCSetup(CfgSetup):
+    def __init__(self, pedb, **kwargs):
+        super().__init__(pedb, **kwargs)
+        self.dc_slider_position = kwargs.get("dc_slider_position")
+        self.dc_ir_settings = CfgDcIrSettings(**kwargs.get("dc_ir_settings", {}))
+        self.freq_sweep = None
+
+    def apply(self):
+        edb_setup = self._pedb.create_siwave_dc_setup(name=self.name, dc_slider_position=self.dc_slider_position)
+        for k, v in self.dc_ir_settings.get_attributes().items():
+            if k == "dc_slider_postion":
+                edb_setup.dc_settings.dc_slider_position = v
+            else:
+                setattr(edb_setup.dc_ir_settings, k, v)
+
+
+class CfgHFSSSetup(CfgSetup):
+    def __init__(self, pedb, **kwargs):
+        super().__init__(pedb, **kwargs)
+
+        self.f_adapt = kwargs.get("f_adapt")
+        self.max_num_passes = kwargs.get("max_num_passes")
+        self.max_mag_delta_s = kwargs.get("max_mag_delta_s")
+
+        self.mesh_operations = []
+        for i in kwargs.get("mesh_operations", []):
+            self.mesh_operations.append(CfgLengthMeshOperation(**i))
+
+    def apply(self):
+        if self.name in self._pedb.setups:
+            raise "Setup {} already existing. Editing it.".format(self.name)
+
+        edb_setup = self._pedb.create_hfss_setup(self.name)
+        edb_setup.set_solution_single_frequency(self.f_adapt, self.max_num_passes, self.max_mag_delta_s)
+
+        self._apply_freq_sweep(edb_setup)
+
+        for i in self.mesh_operations:
+            edb_setup.add_length_mesh_operation(
+                net_layer_list=i.nets_layers_list,
+                name=i.name,
+                # max_elements=i.max_elements,
+                max_length=i.max_length,
+                # restrict_elements=i.restrict_max_elements,
+                restrict_length=i.restrict_length,
+                refine_inside=i.refine_inside,
+                # mesh_region=i.mesh_region
+            )
+
+
+class CfgDcIrSettings(CfgBase):
+    def __init__(self, **kwargs):
+        self.export_dc_thermal_data = kwargs.get("export_dc_thermal_data")
+
+
+class CfgMeshOperation(CfgBase):
+    def __init__(self, **kwargs):
+        self.name = kwargs.get("name")
+        self.type = kwargs.get("type")
+        # self.mesh_region = kwargs.get("mesh_region")
+        self.nets_layers_list = kwargs.get("nets_layers_list", {})
+        self.refine_inside = kwargs.get("refine_inside", False)
+
+
+class CfgLengthMeshOperation(CfgMeshOperation):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+
+        # waiting bug review
+        # self.restrict_max_elements = kwargs.get("restrict_max_elements", True)
+        # self.max_elements = kwargs.get("max_elements", 1000)
+        self.restrict_length = kwargs.get("restrict_length", True)
+        self.max_length = kwargs.get("max_length", "1mm")
+
+
+class CfgSetups:
+    def __init__(self, pedb, setups_data):
+        self._pedb = pedb
+        self.setups = []
+        for stp in setups_data:
+            if stp.get("type").lower() == "hfss":
+                self.setups.append(CfgHFSSSetup(self._pedb, **stp))
+            elif stp.get("type").lower() in ["siwave_ac", "siwave_syz"]:
+                self.setups.append(CfgSIwaveACSetup(self._pedb, **stp))
+            elif stp.get("type").lower() == "siwave_dc":
+                self.setups.append(CfgSIwaveDCSetup(self._pedb, **stp))
+
+    def apply(self):
+        for s in self.setups:
+            s.apply()
+
+    def get_data_from_db(self):
+        setups = []
+        for _, s in self._pedb.setups.items():
+            stp = {}
+            if s.type == "hfss":
+                for p_name in CfgHFSSSetup(self._pedb).__dict__:
+                    if p_name.startswith("_"):
+                        continue
+                    elif p_name == "type":
+                        stp[p_name] = s.type
+                    elif p_name == "f_adapt":
+                        stp[p_name] = list(s.adaptive_settings.adaptive_frequency_data_list)[0].adaptive_frequency
+                    elif p_name == "max_num_passes":
+                        stp[p_name] = list(s.adaptive_settings.adaptive_frequency_data_list)[0].max_passes
+                    elif p_name == "max_mag_delta_s":
+                        stp[p_name] = list(s.adaptive_settings.adaptive_frequency_data_list)[0].max_delta
+                    elif p_name == "freq_sweep":
+                        f_sweep = []
+                        for _, sw in s.sweeps.items():
+                            sweep_data = {}
+                            for sw_p_name in CfgSweepData().__dict__:
+                                if sw_p_name == "frequencies":
+                                    pass  # Frequencies cannot be read from EDB
+                                else:
+                                    sweep_data[sw_p_name] = getattr(sw, sw_p_name)
+                            f_sweep.append(sweep_data)
+                        stp["freq_sweep"] = f_sweep
+                    elif p_name == "mesh_operations":
+                        mops = []
+                        for _, i in s.mesh_operations.items():
+                            mop = {}
+                            for mop_p_name in CfgLengthMeshOperation().__dict__:
+                                mop[mop_p_name] = getattr(i, mop_p_name)
+                            mops.append(mop)
+                        stp["mesh_operations"] = mops
+                    else:
+                        stp[p_name] = getattr(s, p_name)
+
+            elif s.type == "siwave_ac":
+                for p_name in CfgSIwaveACSetup(self._pedb).__dict__:
+                    if p_name.startswith("_"):
+                        continue
+                    elif p_name == "freq_sweep":
+                        pass  # Bug in EDB API
+                    else:
+                        stp[p_name] = getattr(s, p_name)
+            elif s.type == "siwave_dc":
+                for p_name in CfgSIwaveDCSetup(self._pedb).__dict__:
+                    if p_name.startswith("_"):
+                        continue
+                    elif p_name == "freq_sweep":
+                        pass
+                    elif p_name == "dc_ir_settings":
+                        dc_ir_s = {}
+                        for dcir_p_name in CfgDcIrSettings().__dict__:
+                            dc_ir_s[dcir_p_name] = getattr(s.dc_ir_settings, dcir_p_name)
+                        stp["dc_ir_settings"] = dc_ir_s
+                    elif p_name == "dc_slider_position":
+                        stp[p_name] = getattr(s.dc_settings, p_name)
+                    else:
+                        stp[p_name] = getattr(s, p_name)
+            setups.append(stp)
+        return setups

{pyedb-0.15.dev0 → pyedb-0.17.0}/src/pyedb/configuration/cfg_stackup.py

@@ -127,7 +127,7 @@ class CfgStackup:
             attrs = mat_in_cfg.get_attributes()
             mat = self._pedb.materials.add_material(**attrs)
 
-    def __get_materials_from_db(self):
+    def get_materials_from_db(self):
         materials = []
         for name, p in self._pedb.materials.materials.items():
             mat = {}
@@ -136,7 +136,7 @@ class CfgStackup:
             materials.append(mat)
         return materials
 
-    def __get_layers_from_db(self):
+    def get_layers_from_db(self):
         layers = []
         for name, obj in self._pedb.stackup.all_layers.items():
             layer = {}
@@ -155,8 +155,8 @@ class CfgStackup:
         dict
         """
         stackup = {}
-        materials = self.__get_materials_from_db()
+        materials = self.get_materials_from_db()
         stackup["materials"] = materials
-        layers = self.__get_layers_from_db()
+        layers = self.get_layers_from_db()
         stackup["layers"] = layers
         return stackup

{pyedb-0.15.dev0 → pyedb-0.17.0}/src/pyedb/configuration/configuration.py

@@ -131,9 +131,8 @@ class Configuration:
         for source in self.cfg_data.sources:
             source.create()
 
-        # Configure HFSS setup
-        for setup in self.cfg_data.setups:
-            setup.apply()
+        # Configure setup
+        self.cfg_data.setups.apply()
 
         # Configure stackup
         self.cfg_data.stackup.apply()
@@ -264,15 +263,20 @@ class Configuration:
         -------
 
         """
+        self._pedb.logger.info("Getting data from layout database.")
         data = {}
         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("components", False):
+            data["components"] = self.cfg_data.components.get_data_from_db()
 
         return data
 
-    def export(self, file_path, stackup=True, package_definitions=True):
+    def export(self, file_path, stackup=True, package_definitions=True, setups=True):
         """Export the configuration data from layout to a file.
 
         Parameters
@@ -288,7 +292,7 @@ class Configuration:
         """
         file_path = file_path if isinstance(file_path, Path) else Path(file_path)
         file_path = file_path if file_path.suffix == ".json" else file_path.with_suffix(".json")
-        data = self.get_data_from_db(stackup=stackup, package_definitions=package_definitions)
+        data = self.get_data_from_db(stackup=stackup, package_definitions=package_definitions, setups=setups)
         with open(file_path, "w") as f:
             json.dump(data, f, ensure_ascii=False, indent=4)
         return True if os.path.isfile(file_path) else False