pyedb 0.15.dev0__py3-none-any.whl → 0.16.0__py3-none-any.whl

pyedb/__init__.py

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

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/configuration/cfg_components.py

@@ -51,6 +51,8 @@ class CfgRlcModel(CfgBase):
 
 
 class CfgComponent(CfgBase):
+    protected_attributes = ["reference_designator"]
+
     def __init__(self, **kwargs):
         self.enabled = kwargs.get("enabled", None)
 
@@ -65,15 +67,11 @@ class CfgComponent(CfgBase):
 
         self.rlc_model = [CfgRlcModel(**rlc_m) for rlc_m in rlc_models]
 
-    @property
-    def protected_attributes(self):
-        return ["reference_designator"]
-
 
 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

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/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/configuration/cfg_setup.py

@@ -20,182 +20,220 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-from enum import Enum
-
-
-class FrequencySweep:
-    def __init__(self, sweep_dict=None):
-        self._sweep_dict = sweep_dict
-        self.name = "PyEDB_sweep"
-        self.type = self.SweepType.INTERPOLATING
-        self.distribution = [self.Distribution()]
-        if sweep_dict:
-            self.name = self._sweep_dict.get("name", "PyEDB_sweep")
-            frequencies = self._sweep_dict.get("frequencies", None)
-            self._map_sweep_type()
-            self.distribution = [self.Distribution(dist) for dist in frequencies]
-
-    class SweepType(Enum):
-        INTERPOLATING = 0
-        DISCRETE = 1
-
-    class Distribution:
-        def __init__(self, distribution_dict=None):
-            self.type = self.DistributionType.LINEAR_STEP
-            self.start = "0GHz"
-            self.stop = "10GHz"
-            self.step = "10MHz"
-            self.count = 100
-            if distribution_dict:
-                self.map(distribution_dict)
-
-        class DistributionType(Enum):
-            LINEAR_STEP = 0
-            LINEAR_COUNT = 1
-            LOG_SCALE = 2
-
-        def map(self, distribution_dict):
-            distribution_type = distribution_dict.get("distribution", "linear step")
-            if distribution_type == "linear step":
-                self.type = self.DistributionType.LINEAR_STEP
-            elif distribution_type == "linear count":
-                self.type = self.DistributionType.LINEAR_COUNT
-            elif distribution_type == "log scale":
-                self.type = self.DistributionType.LOG_SCALE
-            else:
-                self.type = self.DistributionType.LINEAR_STEP
-            self.start = distribution_dict.get("start", "OGHz")
-            self.stop = distribution_dict.get("stop", "10GHz")
-            self.step = distribution_dict.get("step", "10MHz")
-            self.count = distribution_dict.get("count", 100)
-
-    def _map_sweep_type(self):
-        if self._sweep_dict.get("type", "discrete"):
-            self.type = self.SweepType.DISCRETE
-        else:
-            self.type = self.SweepType.INTERPOLATING
-
-
-class CfgDcSetup:
-    def __init__(self):
-        self.dc_slider_position = 1
-        self.dcir_settings = DcIrSettings()
-
-
-class DcIrSettings:
-    def __init__(self):
-        self.export_dc_thermal_data = True
-
-
-class CfgSetup:
-    def __init__(self, pdata, setup_dict=None):
-        self._pedb = pdata._pedb
-        self._setup_dict = None
-        self.name = "PyEDB_setup"
-        self.type = self.SetupType.HFSS
-        self.f_adapt = "5GHz"
-        self.max_num_passes = 30
-        self.max_mag_delta_s = 0.02
-        self.sweeps = [FrequencySweep()]
-        self.dc_settings = CfgDcSetup()
-        self.si_slider_position = 1
-        self.pi_slider_position = 1
-        if setup_dict:
-            self._setup_dict = setup_dict
-            self.name = setup_dict.get("name", "PyEDB_setup")
-            self._map_setup_type(setup_dict.get("type", None))
-            self.f_adapt = setup_dict.get("f_adapt", "5GHz")
-            self.max_mag_delta_s = setup_dict.get("max_mag_delta_s", 0.02)
-            if setup_dict.get("freq_sweep", None):
-                self.sweeps = [FrequencySweep(sweep) for sweep in setup_dict.get("freq_sweep", None)]
-            else:
-                self.sweeps = []
-            self.dc_settings.dc_slider_position = setup_dict.get("dc_slider_position", 1)
-            if setup_dict.get("dc_ir_settings", None):
-                dc_ir_dict = setup_dict.get("dc_ir_settings")
-                self.dc_settings.dcir_settings.export_dc_thermal_data = dc_ir_dict.get("export_dc_thermal_data", True)
-
-    def _map_setup_type(self, setup_type):
-        if setup_type.upper() == "HFSS":
-            self.type = self.SetupType.HFSS
-        elif setup_type.upper() == "HFSS_PI":
-            self.type = self.SetupType.HFSS_PI
-        elif setup_type.upper() == "SIWAVE_SYZ":
-            self.type = self.SetupType.SIWAVE_SYZ
-        elif setup_type.upper() == "SIWAVE_DC":
-            self.type = self.SetupType.SIWAVE_DC
-        elif setup_type.upper() == "RAPTORX":
-            self.type = self.SetupType.RAPTORX
-        elif setup_type.upper() == "Q3D":
-            self.type = self.SetupType.Q3D
-        else:
-            self.type = self.SetupType.HFSS
-
-    class SetupType(Enum):
-        HFSS = 0
-        SIWAVE_SYZ = 1
-        SIWAVE_DC = 2
-        HFSS_PI = 3
-        RAPTORX = 4
-        Q3D = 5
+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):
-        edb_setup = None
-        if self.type == self.SetupType.SIWAVE_DC:
-            if self.name not in self._pedb.setups:
-                edb_setup = self._pedb.create_siwave_dc_setup(self.name)
-                self._pedb.logger.info("Setup {} created.".format(self.name))
-            else:
-                self._pedb.logger.warning("Setup {} already existing. Editing it.".format(self.name))
-            edb_setup = self._pedb.setups[self.name]
-            edb_setup.set_dc_slider(self.dc_settings.dc_slider_position)
-            # TODO add DCIR settings in EDB setup
-        elif self.type == self.SetupType.HFSS:
-            if self.name not in self._pedb.setups:
-                edb_setup = self._pedb.create_hfss_setup(self.name)
-                self._pedb.logger.info("Setup {} created.".format(self.name))
-            else:
-                self._pedb.logger.warning("Setup {} already existing. Editing it.".format(self.name))
-                edb_setup = self._pedb.setups[self.name]
-            if not edb_setup.set_solution_single_frequency(self.f_adapt, self.max_num_passes, self.max_mag_delta_s):
-                self._pedb.logger.errur(f"Failed to create HFSS simulation setup {self.name}")
-        elif self.type == self.SetupType.SIWAVE_SYZ:
-            if self.name not in self._pedb.setups:
-                edb_setup = self._pedb.create_siwave_syz_setup(self.name)
-                self._pedb.logger.info("Setup {} created.".format(self.name))
+        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:
-                self._pedb.logger.warning("Setup {} already existing. Editing it.".format(self.name))
-                edb_setup = self._pedb.setups[self.name]
-                edb_setup.si_slider_position = self.si_slider_position
-                edb_setup.pi_slider_position = self.pi_slider_position
-        for sweep in self.sweeps:
-            for dist in sweep.distribution:
-                freqs = []
-                if dist.type == dist.DistributionType.LINEAR_STEP:
-                    freqs.append(
-                        [
-                            "linear scale",
-                            self._pedb.edb_value(dist.start).ToString(),
-                            self._pedb.edb_value(dist.stop).ToString(),
-                            self._pedb.edb_value(dist.step).ToString(),
-                        ]
-                    )
-                elif dist.type == dist.DistributionType.LINEAR_COUNT:
-                    freqs.append(
-                        [
-                            "linear count",
-                            self._pedb.edb_value(dist.start).ToString(),
-                            self._pedb.edb_value(dist.stop).ToString(),
-                            int(dist.count),
-                        ]
-                    )
-                elif dist.type == dist.DistributionType.LOG_SCALE:
-                    freqs.append(
-                        [
-                            "log scale",
-                            self._pedb.edb_value(dist.start).ToString(),
-                            self._pedb.edb_value(dist.stop).ToString(),
-                            int(dist.count),
-                        ]
-                    )
-                edb_setup.add_frequency_sweep(sweep.name, frequency_sweep=freqs)
+                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/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/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,18 @@ 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()
 
         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 +290,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