pyedb 0.15.0__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.0"
+__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

pyedb/dotnet/edb.py

@@ -3681,7 +3681,7 @@ class Edb(Database):
             return False
         return HFSSPISimulationSetup(self).create(name)
 
-    def create_siwave_syz_setup(self, name=None):
+    def create_siwave_syz_setup(self, name=None, **kwargs):
         """Create a setup from a template.
 
         Parameters
@@ -3709,9 +3709,11 @@ class Edb(Database):
         if name in self.setups:
             return False
         setup = SiwaveSimulationSetup(self, name=name)
+        for k, v in kwargs.items():
+            setattr(setup, k, v)
         return self.setups[name]
 
-    def create_siwave_dc_setup(self, name=None):
+    def create_siwave_dc_setup(self, name=None, **kwargs):
         """Create a setup from a template.
 
         Parameters
@@ -3736,6 +3738,8 @@ class Edb(Database):
         if name in self.setups:
             return False
         setup = SiwaveDCSimulationSetup(self, name=name)
+        for k, v in kwargs.items():
+            setattr(setup, k, v)
         return setup
 
     def calculate_initial_extent(self, expansion_factor):

pyedb/dotnet/edb_core/layout.py

@@ -149,10 +149,13 @@ class EdbLayout(object):
         _primitives_by_layer = {}
         for lay in self.layers:
             _primitives_by_layer[lay] = []
+        for lay in self._pedb.stackup.non_stackup_layers:
+            _primitives_by_layer[lay] = []
         for i in self._layout.primitives:
             try:
                 lay = i.GetLayer().GetName()
-                _primitives_by_layer[lay].append(cast(i, self._pedb))
+                if lay in _primitives_by_layer:
+                    _primitives_by_layer[lay].append(cast(i, self._pedb))
             except:
                 self._logger.warning(f"Failed to get layer on primitive {i}, skipping.")
                 continue

pyedb/dotnet/edb_core/sim_setup_data/data/mesh_operation.py

@@ -20,22 +20,31 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+from enum import Enum
+
 from System import Tuple
 
 from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
 
 
+class MeshOpType(Enum):
+    kMeshSetupBase = "base"
+    kMeshSetupLength = "length"
+    kMeshSetupSkinDepth = "skin_depth"
+    kNumMeshOpTypes = "num_mesh_op_types"
+
+
 class MeshOperation(object):
     """Mesh Operation Class."""
 
-    def __init__(self, parent, mesh_operation):
+    def __init__(self, parent, edb_object):
         self._parent = parent
-        self.mesh_operation = mesh_operation
+        self._edb_object = edb_object
         self._mesh_op_mapping = {
-            "kMeshSetupBase": mesh_operation.TMeshOpType.kMeshSetupBase,
-            "kMeshSetupLength": mesh_operation.TMeshOpType.kMeshSetupLength,
-            "kMeshSetupSkinDepth": mesh_operation.TMeshOpType.kMeshSetupSkinDepth,
-            "kNumMeshOpTypes": mesh_operation.TMeshOpType.kNumMeshOpTypes,
+            "kMeshSetupBase": self._edb_object.TMeshOpType.kMeshSetupBase,
+            "kMeshSetupLength": self._edb_object.TMeshOpType.kMeshSetupLength,
+            "kMeshSetupSkinDepth": self._edb_object.TMeshOpType.kMeshSetupSkinDepth,
+            "kNumMeshOpTypes": self._edb_object.TMeshOpType.kNumMeshOpTypes,
         }
 
     @property
@@ -47,7 +56,7 @@ class MeshOperation(object):
         bool
             ``True`` if mesh operation is used, ``False`` otherwise.
         """
-        return self.mesh_operation.Enabled
+        return self._edb_object.Enabled
 
     @property
     def mesh_operation_type(self):
@@ -60,9 +69,14 @@ class MeshOperation(object):
 
         Returns
         -------
-        int
+        str
         """
-        return self.mesh_operation.MeshOpType.ToString()
+        return self._edb_object.MeshOpType.ToString()
+
+    @property
+    def type(self):
+        mop_type = self.mesh_operation_type
+        return MeshOpType[mop_type].value
 
     @property
     def mesh_region(self):
@@ -73,7 +87,7 @@ class MeshOperation(object):
         str
             Name of the mesh region.
         """
-        return self.mesh_operation.MeshRegion
+        return self._edb_object.MeshRegion
 
     @property
     def name(self):
@@ -83,7 +97,7 @@ class MeshOperation(object):
         -------
         str
         """
-        return self.mesh_operation.Name
+        return self._edb_object.Name
 
     @property
     def nets_layers_list(self):
@@ -99,7 +113,18 @@ class MeshOperation(object):
            Third element is represents whether if the mesh operation is enabled or disabled.
 
         """
-        return self.mesh_operation.NetsLayersList
+        nets_layers = {}
+        for i in list(self._edb_object.NetsLayersList):
+            net = i.Item1
+            layer = i.Item2
+            flag = i.Item3
+            if not flag:
+                continue
+            if net not in nets_layers:
+                nets_layers[net] = [layer]
+            else:
+                nets_layers[net].append(layer)
+        return nets_layers
 
     @nets_layers_list.setter
     def nets_layers_list(self, values):
@@ -107,7 +132,7 @@ class MeshOperation(object):
         for net, layers in values.items():
             for layer in layers:
                 temp.append(Tuple[str, str, bool](net, layer, True))
-        self.mesh_operation.NetsLayersList = convert_py_list_to_net_list(temp)
+        self._edb_object.NetsLayersList = convert_py_list_to_net_list(temp)
 
     @property
     def refine_inside(self):
@@ -119,27 +144,23 @@ class MeshOperation(object):
             ``True`` if refine inside objects is used, ``False`` otherwise.
 
         """
-        return self.mesh_operation.RefineInside
+        return self._edb_object.RefineInside
 
     @enabled.setter
     def enabled(self, value):
-        self.mesh_operation.Enabled = value
-        self._parent._update_setup()
+        self._edb_object.Enabled = value
 
     @mesh_region.setter
     def mesh_region(self, value):
-        self.mesh_operation.MeshRegion = value
-        self._parent._update_setup()
+        self._edb_object.MeshRegion = value
 
     @name.setter
     def name(self, value):
-        self.mesh_operation.Name = value
-        self._parent._update_setup()
+        self._edb_object.Name = value
 
     @refine_inside.setter
     def refine_inside(self, value):
-        self.mesh_operation.RefineInside = value
-        self._parent._update_setup()
+        self._edb_object.RefineInside = value
 
     @property
     def max_elements(self):
@@ -149,7 +170,7 @@ class MeshOperation(object):
         -------
         str
         """
-        return self.mesh_operation.MaxElems
+        return int(self._edb_object.MaxElems)
 
     @property
     def restrict_max_elements(self):
@@ -159,12 +180,11 @@ class MeshOperation(object):
         -------
         bool
         """
-        return self.mesh_operation.RestrictMaxElem
+        return self._edb_object.RestrictMaxElem
 
     @max_elements.setter
     def max_elements(self, value):
-        self.mesh_operation.MaxElems = str(value)
-        self._parent._update_setup()
+        self._edb_object.MaxElems = str(value)
 
     @restrict_max_elements.setter
     def restrict_max_elements(self, value):
@@ -174,11 +194,10 @@ class MeshOperation(object):
         -------
         bool
         """
-        self.mesh_operation.RestrictMaxElem = value
-        self._parent._update_setup()
+        self._edb_object.RestrictMaxElem = value
 
 
-class MeshOperationLength(MeshOperation, object):
+class LengthMeshOperation(MeshOperation, object):
     """Mesh operation Length class.
     This class is accessible from Hfss Setup in EDB and add_length_mesh_operation method.
 
@@ -188,8 +207,8 @@ class MeshOperationLength(MeshOperation, object):
     >>> mop.max_elements = 3000
     """
 
-    def __init__(self, parent, mesh_operation):
-        MeshOperation.__init__(self, parent, mesh_operation)
+    def __init__(self, parent, edb_object):
+        MeshOperation.__init__(self, parent, edb_object)
 
     @property
     def max_length(self):
@@ -199,7 +218,7 @@ class MeshOperationLength(MeshOperation, object):
         -------
         str
         """
-        return self.mesh_operation.MaxLength
+        return self._edb_object.MaxLength
 
     @property
     def restrict_length(self):
@@ -209,12 +228,11 @@ class MeshOperationLength(MeshOperation, object):
         -------
         bool
         """
-        return self.mesh_operation.RestrictLength
+        return self._edb_object.RestrictLength
 
     @max_length.setter
     def max_length(self, value):
-        self.mesh_operation.MaxLength = value
-        self._parent._update_setup()
+        self._edb_object.MaxLength = value
 
     @restrict_length.setter
     def restrict_length(self, value):
@@ -224,11 +242,10 @@ class MeshOperationLength(MeshOperation, object):
         -------
         bool
         """
-        self.mesh_operation.RestrictLength = value
-        self._parent._update_setup()
+        self._edb_object.RestrictLength = value
 
 
-class MeshOperationSkinDepth(MeshOperation, object):
+class SkinDepthMeshOperation(MeshOperation, object):
     """Mesh operation Skin Depth class.
     This class is accessible from Hfss Setup in EDB and assign_skin_depth_mesh_operation method.
 
@@ -238,8 +255,8 @@ class MeshOperationSkinDepth(MeshOperation, object):
     >>> mop.max_elements = 3000
     """
 
-    def __init__(self, parent, mesh_operation):
-        MeshOperation.__init__(self, parent, mesh_operation)
+    def __init__(self, parent, edb_object):
+        MeshOperation.__init__(self, parent, edb_object)
 
     @property
     def skin_depth(self):
@@ -249,12 +266,11 @@ class MeshOperationSkinDepth(MeshOperation, object):
         -------
         str
         """
-        return self.mesh_operation.SkinDepth
+        return self._edb_object.SkinDepth
 
     @skin_depth.setter
     def skin_depth(self, value):
-        self.mesh_operation.SkinDepth = value
-        self._parent._update_setup()
+        self._edb_object.SkinDepth = value
 
     @property
     def surface_triangle_length(self):
@@ -264,12 +280,11 @@ class MeshOperationSkinDepth(MeshOperation, object):
         -------
         str
         """
-        return self.mesh_operation.SurfTriLength
+        return self._edb_object.SurfTriLength
 
     @surface_triangle_length.setter
     def surface_triangle_length(self, value):
-        self.mesh_operation.SurfTriLength = value
-        self._parent._update_setup()
+        self._edb_object.SurfTriLength = value
 
     @property
     def number_of_layer_elements(self):
@@ -279,9 +294,8 @@ class MeshOperationSkinDepth(MeshOperation, object):
         -------
         str
         """
-        return self.mesh_operation.NumLayers
+        return self._edb_object.NumLayers
 
     @number_of_layer_elements.setter
     def number_of_layer_elements(self, value):
-        self.mesh_operation.NumLayers = str(value)
-        self._parent._update_setup()
+        self._edb_object.NumLayers = str(value)

pyedb/dotnet/edb_core/sim_setup_data/data/sweep_data.py

@@ -63,11 +63,6 @@ class SweepData(object):
         self._edb_object.Name = value
         self._update_sweep()
 
-    @property
-    def sweep_type(self):
-        """Sweep type."""
-        return
-
     @property
     def frequencies(self):
         """List of frequency points."""
@@ -159,6 +154,39 @@ class SweepData(object):
         """
         return self._edb_object.FreqSweepType.ToString()
 
+    @freq_sweep_type.setter
+    def freq_sweep_type(self, value):
+        edb_freq_sweep_type = self._edb_object.TFreqSweepType
+        if value in [0, "kInterpolatingSweep"]:
+            self._edb_object.FreqSweepType = edb_freq_sweep_type.kInterpolatingSweep
+        elif value in [1, "kDiscreteSweep"]:
+            self._edb_object.FreqSweepType = edb_freq_sweep_type.kDiscreteSweep
+        elif value in [2, "kBroadbandFastSweep"]:
+            self._edb_object.FreqSweepType = edb_freq_sweep_type.kBroadbandFastSweep
+        elif value in [3, "kNumSweepTypes"]:
+            self._edb_object.FreqSweepType = edb_freq_sweep_type.kNumSweepTypes
+        self._edb_object.FreqSweepType.ToString()
+
+    @property
+    def type(self):
+        """Sweep type."""
+        sw_type = self.freq_sweep_type
+        if sw_type == "kInterpolatingSweep":
+            return "interpolation"
+        elif sw_type == "kDiscreteSweep":
+            return "discrete"
+        elif sw_type == "kBroadbandFastSweep":
+            return "broadband"
+
+    @type.setter
+    def type(self, value):
+        if value == "interpolation":
+            self.freq_sweep_type = "kInterpolatingSweep"
+        elif value == "discrete":
+            self.freq_sweep_type = "kDiscreteSweep"
+        elif value == "broadband":
+            self.freq_sweep_type = "kBroadbandFastSweep"
+
     @property
     def interpolation_use_full_basis(self):
         """Flag indicating if full-basis elements is used.
@@ -318,19 +346,6 @@ class SweepData(object):
         self._edb_object.EnforcePassivity = value
         self._update_sweep()
 
-    @freq_sweep_type.setter
-    def freq_sweep_type(self, value):
-        edb_freq_sweep_type = self._edb_object.TFreqSweepType
-        if value in [0, "kInterpolatingSweep"]:
-            self._edb_object.FreqSweepType = edb_freq_sweep_type.kInterpolatingSweep
-        elif value in [1, "kDiscreteSweep"]:
-            self._edb_object.FreqSweepType = edb_freq_sweep_type.kDiscreteSweep
-        elif value in [2, "kBroadbandFastSweep"]:
-            self._edb_object.FreqSweepType = edb_freq_sweep_type.kBroadbandFastSweep
-        elif value in [3, "kNumSweepTypes"]:
-            self._edb_object.FreqSweepType = edb_freq_sweep_type.kNumSweepTypes
-        self._edb_object.FreqSweepType.ToString()
-
     @interpolation_use_full_basis.setter
     def interpolation_use_full_basis(self, value):
         self._edb_object.InterpUseFullBasis = value
@@ -506,20 +521,24 @@ class SweepData(object):
 
     def add(self, sweep_type, start, stop, increment):
         sweep_type = sweep_type.replace(" ", "_")
+        start = start.upper().replace("Z", "z") if isinstance(start, str) else str(start)
+        stop = stop.upper().replace("Z", "z") if isinstance(stop, str) else str(stop)
+        increment = increment.upper().replace("Z", "z") if isinstance(increment, str) else int(increment)
         if sweep_type in ["linear_count", "linear_scale"]:
             freqs = list(self._edb_object.SetFrequencies(start, stop, increment))
         elif sweep_type == "log_scale":
             freqs = list(self._edb_object.SetLogFrequencies(start, stop, increment))
         else:
             raise ValueError("sweep_type must be either 'linear_count', 'linear_scale' or 'log_scale")
-        self.add_frequencies(freqs)
+        return self.add_frequencies(freqs)
 
     def add_frequencies(self, frequencies):
         if not isinstance(frequencies, list):
             frequencies = [frequencies]
         for i in frequencies:
-            i = str(self._pedb.edb_value(i).ToDouble())
+            i = self._pedb.edb_value(i).ToString()
             self._edb_object.Frequencies.Add(i)
+        return list(self._edb_object.Frequencies)
 
     def clear(self):
         self._edb_object.Frequencies.Clear()

pyedb/dotnet/edb_core/utilities/hfss_simulation_setup.py

@@ -23,8 +23,8 @@
 import warnings
 
 from pyedb.dotnet.edb_core.sim_setup_data.data.mesh_operation import (
-    MeshOperationLength,
-    MeshOperationSkinDepth,
+    LengthMeshOperation,
+    SkinDepthMeshOperation,
 )
 from pyedb.dotnet.edb_core.sim_setup_data.data.settings import (
     AdaptiveSettings,
@@ -198,11 +198,11 @@ class HfssSimulationSetup(SimulationSetup):
         mesh_operations = {}
         for i in list(settings):
             if i.MeshOpType == i.TMeshOpType.kMeshSetupLength:
-                mesh_operations[i.Name] = MeshOperationLength(self, i)
+                mesh_operations[i.Name] = LengthMeshOperation(self, i)
             elif i.MeshOpType == i.TMeshOpType.kMeshSetupSkinDepth:
-                mesh_operations[i.Name] = MeshOperationSkinDepth(self, i)
+                mesh_operations[i.Name] = SkinDepthMeshOperation(self, i)
             elif i.MeshOpType == i.TMeshOpType.kMeshSetupBase:
-                mesh_operations[i.Name] = MeshOperationSkinDepth(self, i)
+                mesh_operations[i.Name] = SkinDepthMeshOperation(self, i)
 
         return mesh_operations
 
@@ -244,18 +244,18 @@ class HfssSimulationSetup(SimulationSetup):
         """
         if not name:
             name = generate_unique_name("skin")
-        mesh_operation = MeshOperationLength(self, self._pedb.simsetupdata.LengthMeshOperation())
-        mesh_operation.mesh_region = mesh_region
-        mesh_operation.name = name
-        mesh_operation.nets_layers_list = net_layer_list
-        mesh_operation.refine_inside = refine_inside
-        mesh_operation.max_elements = str(max_elements)
-        mesh_operation.max_length = max_length
-        mesh_operation.restrict_length = restrict_length
-        mesh_operation.restrict_max_elements = restrict_elements
-        self.sim_setup_info.simulation_settings.MeshOperations.Add(mesh_operation.mesh_operation)
+        mop = LengthMeshOperation(self, self._pedb.simsetupdata.LengthMeshOperation())
+        mop.mesh_region = mesh_region
+        mop.name = name
+        mop.nets_layers_list = net_layer_list
+        mop.refine_inside = refine_inside
+        mop.max_elements = max_elements
+        mop.max_length = max_length
+        mop.restrict_length = restrict_length
+        mop.restrict_max_elements = restrict_elements
+        self.sim_setup_info.simulation_settings.MeshOperations.Add(mop._edb_object)
         self._update_setup()
-        return mesh_operation
+        return mop
 
     def add_skin_depth_mesh_operation(
         self,
@@ -298,7 +298,7 @@ class HfssSimulationSetup(SimulationSetup):
         """
         if not name:
             name = generate_unique_name("length")
-        mesh_operation = MeshOperationSkinDepth(self, self._pedb.simsetupdata.SkinDepthMeshOperation())
+        mesh_operation = SkinDepthMeshOperation(self, self._pedb.simsetupdata.SkinDepthMeshOperation())
         mesh_operation.mesh_region = mesh_region
         mesh_operation.name = name
         mesh_operation.nets_layers_list = net_layer_list
@@ -308,7 +308,7 @@ class HfssSimulationSetup(SimulationSetup):
         mesh_operation.number_of_layer_elements = number_of_layers
         mesh_operation.surface_triangle_length = surface_triangle_length
         mesh_operation.restrict_max_elements = restrict_elements
-        self.sim_setup_info.simulation_settings.MeshOperations.Add(mesh_operation.mesh_operation)
+        self.sim_setup_info.simulation_settings.MeshOperations.Add(mesh_operation._edb_object)
         self._update_setup()
         return mesh_operation
 

pyedb/dotnet/edb_core/utilities/simulation_setup.py

@@ -21,6 +21,7 @@
 # SOFTWARE.
 
 
+from enum import Enum
 import warnings
 
 from pyedb.dotnet.edb_core.sim_setup_data.data.sim_setup_info import SimSetupInfo
@@ -28,6 +29,23 @@ from pyedb.dotnet.edb_core.sim_setup_data.data.sweep_data import SweepData
 from pyedb.generic.general_methods import generate_unique_name
 
 
+class SimulationSetupType(Enum):
+    kHFSS = "hfss"
+    kPEM = None
+    kSIwave = "siwave_ac"
+    kLNA = "lna"
+    kTransient = "transient"
+    kQEye = "quick_eye"
+    kVEye = "verif_eye"
+    kAMI = "ami"
+    kAnalysisOption = "analysis_option"
+    kSIwaveDCIR = "siwave_dc"
+    kSIwaveEMI = "siwave_emi"
+    kHFSSPI = "hfss_pi"
+    kDDRwizard = "ddrwizard"
+    kQ3D = "q3d"
+
+
 class AdaptiveType(object):
     (SingleFrequency, MultiFrequency, BroadBand) = range(0, 3)
 
@@ -92,6 +110,10 @@ class SimulationSetup(object):
     def setup_type(self):
         return self.sim_setup_info.sim_setup_type
 
+    @property
+    def type(self):
+        return SimulationSetupType[self.setup_type].value
+
     def _create(self, name=None, simulation_setup_type=""):
         """Create a simulation setup."""
         if not name:
@@ -137,9 +159,12 @@ class SimulationSetup(object):
         setup_utility = setup_type_mapping[sim_setup_type.ToString()]
         return setup_utility(edb_setup_info)
 
+    @property
+    def mesh_operations(self):
+        return {}
+
     def _update_setup(self):
         """Update setup in EDB."""
-        # Update mesh operation
         # Update sweep
 
         # Replace setup
@@ -209,7 +234,7 @@ class SimulationSetup(object):
         else:
             return {i.name: i for i in self.sim_setup_info.sweep_data_list}
 
-    def add_sweep(self, name, frequency_set: list = None):
+    def add_sweep(self, name, frequency_set: list = None, **kwargs):
         """Add frequency sweep.
 
         Parameters
@@ -232,10 +257,16 @@ class SimulationSetup(object):
             raise ValueError("Sweep {} already exists.".format(name))
 
         sweep_data = SweepData(self._pedb, name=name, sim_setup=self)
+        for k, v in kwargs.items():
+            if k in dir(sweep_data):
+                setattr(sweep_data, k, v)
+
         if frequency_set is None:
             sweep_type = "linear_scale"
             start, stop, increment = "50MHz", "5GHz", "50MHz"
             sweep_data.add(sweep_type, start, stop, increment)
+        elif len(frequency_set) == 0:
+            pass
         else:
             if not isinstance(frequency_set[0], list):
                 frequency_set = [frequency_set]

{pyedb-0.15.0.dist-info → pyedb-0.16.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyedb
-Version: 0.15.0
+Version: 0.16.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: numpy>=1.20.0,<3
+Requires-Dist: numpy>=1.20.0,<2
 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.26 ; extra == "doc"
@@ -41,7 +41,7 @@ Requires-Dist: sphinx_design>=0.4.0,<0.7 ; extra == "doc"
 Requires-Dist: matplotlib>=3.5.0,<3.10 ; extra == "full"
 Requires-Dist: pandas>=1.1.0,<2.3 ; extra == "full"
 Requires-Dist: matplotlib>=3.5.0,<3.10 ; extra == "tests"
-Requires-Dist: numpy>=1.20.0,<3 ; extra == "tests"
+Requires-Dist: numpy>=1.20.0,<2 ; extra == "tests"
 Requires-Dist: mock>=5.1.0,<5.2 ; extra == "tests"
 Requires-Dist: pandas>=1.1.0,<2.3 ; extra == "tests"
 Requires-Dist: pytest>=7.4.0,<8.3 ; extra == "tests"

{pyedb-0.15.0.dist-info → pyedb-0.16.0.dist-info}/RECORD

@@ -1,34 +1,34 @@
-pyedb/__init__.py,sha256=ikLG55mimstWvvlVdh0MuRlCP8bx_lJ9dx4rzqN0Fr8,1521
+pyedb/__init__.py,sha256=HAdok962ENPcSNP4YCzTRB8o8iRR7OcPNmQT6sD08pE,1521
 pyedb/edb_logger.py,sha256=yNkXnoL2me7ubLT6O6r6ElVnkZ1g8fmfFYC_2XJZ1Sw,14950
 pyedb/exceptions.py,sha256=n94xluzUks6BA24vd_L6HkrvoP_H_l6__hQmqzdCyPo,111
 pyedb/siwave.py,sha256=p-j2AmJ3RPG9IKieDxiVPRhzRlXbjpxENP9GHAgT6l8,13086
 pyedb/configuration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyedb/configuration/cfg_boundaries.py,sha256=ckb-OfaObItwy-xc0LqkHJyeCfKC5vg668olPjZbaKo,6647
-pyedb/configuration/cfg_common.py,sha256=PVLYBv6pWiVAPa4haOsXdC87hH82rpZTkVW-MOqUObs,2020
-pyedb/configuration/cfg_components.py,sha256=5y_aQkHvXTO5TKDY3IaJxcxQMg7bNFnMJtlHVAwgTA8,6021
-pyedb/configuration/cfg_data.py,sha256=9qYp6ZNByi-od5riBNp4WthTuVilFTSH9dA4RhC-dlw,3938
+pyedb/configuration/cfg_common.py,sha256=5ne78TTA0wHpbi804nsUd9SPxNKZvut_X_Miu-xDRgk,1982
+pyedb/configuration/cfg_components.py,sha256=xirPvFvFwMgxHFcA4nnDbXTWZnAaCs9_4T4Kqv2AdtI,6005
+pyedb/configuration/cfg_data.py,sha256=ENvPsPWYD-crwyHWkB0LBAfz9mHjxoVrszwVS_EL0i8,3772
 pyedb/configuration/cfg_general.py,sha256=0dtd-rkQt2aYR3EOL0c3sNuDuJs7htRos1OWck3rxaI,1626
 pyedb/configuration/cfg_nets.py,sha256=SCiBTUVHX3Ub91MEU88m0xcHIot_axT9QTFJ8LawppI,1880
 pyedb/configuration/cfg_operations.py,sha256=OzktdjLgHUm6_kCbMeuZ2mhUXfOIP6gXslmbkB7nZOM,3130
-pyedb/configuration/cfg_package_definition.py,sha256=jLL47ctoEUvkzk7pfh03qLhdv-vfGMdN1IfbboxnAo4,5342
+pyedb/configuration/cfg_package_definition.py,sha256=f_RRT9R-3H5kHBlc4QSpjq9uQgYbaKQ78XXXrc_r3kg,5296
 pyedb/configuration/cfg_padstacks.py,sha256=5t799x_mfwLjCAic-B13v3I6FgDswysXdcKmeOxz4Uo,5571
 pyedb/configuration/cfg_pin_groups.py,sha256=aidsOXTHhEyE8UGRiT1nvyn-3sD0CU_n8RR19AmhQrk,2877
 pyedb/configuration/cfg_ports_sources.py,sha256=Wzs9hmEnOIPtiVXIfZgPM7TGsqV_t6ELbB71wSWG5_g,8166
 pyedb/configuration/cfg_s_parameter_models.py,sha256=NzS3eBjBSnd7ZDk_TsX04dqRcRXompjx1DxCe1UzWMw,2855
-pyedb/configuration/cfg_setup.py,sha256=XDpddzsIXWMHmrY-qonS5aQaFdS2OUZDQy5v8qWLCXE,8792
+pyedb/configuration/cfg_setup.py,sha256=SPpNRLJusB-Cz2fDQkc6gkdilUqIlbNngoxF3zySt6g,10115
 pyedb/configuration/cfg_spice_models.py,sha256=tBY3okFiEffMGvBkpmZQrCrovpt-d62k51_WkkV4jqo,2435
-pyedb/configuration/cfg_stackup.py,sha256=YIFyfGAwnlErPGB5y87Viau_wxISofCHl5fPWVPdYC4,6597
-pyedb/configuration/configuration.py,sha256=At0W6PbIbV72nBzpLlLz0ElP99T5xMB9kNjmdjJ_dck,11275
+pyedb/configuration/cfg_stackup.py,sha256=CX7uNN5QRoYW_MOObknP8003YchTS7PH9Oee7FG0VKU,6589
+pyedb/configuration/configuration.py,sha256=5rpJgprlOt0PDyGCS0F1-ilktSRRD106twv2XTolN08,11444
 pyedb/dotnet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyedb/dotnet/clr_module.py,sha256=Mo13Of3DVSA5HR-5xZEXOiHApIKy52CUxtJ2gPkEu1A,3406
-pyedb/dotnet/edb.py,sha256=QUw9Jv97vXTCB8G-RuILjURt4iYSvHDlwv9cKHOPCww,179407
+pyedb/dotnet/edb.py,sha256=lgA6iwyrNFUupqzF4CicpomYBPAScOzm3DsFVYQOR6U,179565
 pyedb/dotnet/application/Variables.py,sha256=v_fxFJ6xjyyhk4uaMzWAbP-1FhXGuKsVNuyV1huaPME,77867
 pyedb/dotnet/application/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyedb/dotnet/edb_core/__init__.py,sha256=nIRLJ8VZLcMAp12zmGsnZ5x2BEEl7q_Kj_KAOXxVjpQ,52
 pyedb/dotnet/edb_core/components.py,sha256=T7gyIGKvwyocPwGCV806eQyghDiabQs2RIHZE7Rd73M,103709
 pyedb/dotnet/edb_core/general.py,sha256=f-WuyJY1nkfMEXm_fvU7poLfIi4axV1ha5Am1_m2eQ0,4572
 pyedb/dotnet/edb_core/hfss.py,sha256=paHUyp1QtnBHYtswiWEgeaYRvqDT-HdtFG6rmmkD2_w,68815
-pyedb/dotnet/edb_core/layout.py,sha256=cz-SxDFhRpSwpCFL7-bz1Yz7ArM6JsLyDKMSVlch-K8,50110
+pyedb/dotnet/edb_core/layout.py,sha256=ywUnsz01JaGqCO2KIKBrv2u76us08EoBzZyWJGmUrwQ,50263
 pyedb/dotnet/edb_core/layout_validation.py,sha256=_ZcLxePMNauzQxHKWWZGfjuT9tUPS0ZeVKNK7avtJnw,11714
 pyedb/dotnet/edb_core/materials.py,sha256=9HTDzxraPjAl3Jc7beHQfxe6axQY-tw6hDW1A05O2GM,43426
 pyedb/dotnet/edb_core/net_class.py,sha256=fAQoXsjn-Ae3gVYnUJO7yGZ6zEDEf_Zx5Mzq_h0UH7k,11582
@@ -87,19 +87,19 @@ pyedb/dotnet/edb_core/geometry/polygon_data.py,sha256=NQxTlbGPLHf2rW8wgHQzpbPf0z
 pyedb/dotnet/edb_core/sim_setup_data/__init__.py,sha256=8jByHkoaowAYQTCww-zRrTQmN061fLz_OHjTLSrzQQY,58
 pyedb/dotnet/edb_core/sim_setup_data/data/__init__.py,sha256=8jByHkoaowAYQTCww-zRrTQmN061fLz_OHjTLSrzQQY,58
 pyedb/dotnet/edb_core/sim_setup_data/data/adaptive_frequency_data.py,sha256=tlHI7PUUoseNnJAtihpjb1PwXYNr-4ztAAnunlLLWVQ,2463
-pyedb/dotnet/edb_core/sim_setup_data/data/mesh_operation.py,sha256=tP55JjbCvhJiWNNFbyia4_K43j1IkdRo-YtaaoPz5gU,7919
+pyedb/dotnet/edb_core/sim_setup_data/data/mesh_operation.py,sha256=bWKZTMqROiXvG6T3i7EcapcQBcL0gOChDu4tksdk1xo,8073
 pyedb/dotnet/edb_core/sim_setup_data/data/settings.py,sha256=u2EhL_netNF4FTQicWysPeXzkFBqBZhFjdwpu4LuBlk,27624
 pyedb/dotnet/edb_core/sim_setup_data/data/sim_setup_info.py,sha256=dHeyuMm1hRimBx7zrDG0w1q74mIhcUGxk49QoETUq2w,2952
 pyedb/dotnet/edb_core/sim_setup_data/data/simulation_settings.py,sha256=OmaUj4uhRkhIQgm80eLzuAark8rs5Tx6GrSjvYN74Eo,2549
 pyedb/dotnet/edb_core/sim_setup_data/data/siw_dc_ir_settings.py,sha256=b7Zpg6nNQArYxvdxlVhXDzvvCSC5sKFvdt10b0MHkvc,8605
-pyedb/dotnet/edb_core/sim_setup_data/data/sweep_data.py,sha256=fs9kk5futupQUoG_k4lD9krY89YFHwkc7KTHaTdF2DA,17071
+pyedb/dotnet/edb_core/sim_setup_data/data/sweep_data.py,sha256=YeFy9YoYVaieaBTnoXwzo66LyAOrEb5LnNDKv-FAlh8,17970
 pyedb/dotnet/edb_core/sim_setup_data/io/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyedb/dotnet/edb_core/sim_setup_data/io/siwave.py,sha256=XOGBUtFuBJ61lsyylmW0mR_FDbnmwJ7s58r36peREhE,31311
 pyedb/dotnet/edb_core/utilities/__init__.py,sha256=8jByHkoaowAYQTCww-zRrTQmN061fLz_OHjTLSrzQQY,58
 pyedb/dotnet/edb_core/utilities/heatsink.py,sha256=7G7Yx9TxbL5EAiR51MnhdRiAQBVf-d0hKsXDw5OYX2Q,2220
-pyedb/dotnet/edb_core/utilities/hfss_simulation_setup.py,sha256=YJr1k0iRaw3rswcX57YPKCU_kStkLMQkpmrr6FeWBiM,13819
+pyedb/dotnet/edb_core/utilities/hfss_simulation_setup.py,sha256=Uy3w4rRu-c8s0jZ5OqAy_SZl0rPKWff-d_A48wTi3mg,13687
 pyedb/dotnet/edb_core/utilities/obj_base.py,sha256=lufR0sZj0QfZ2wlNvLL6aM1KVqCNY2A7taPPdWcK20w,3312
-pyedb/dotnet/edb_core/utilities/simulation_setup.py,sha256=_yRSgYZRXWZw-uS7fXREIhhT3g4XtJM-trXvWfoYIYc,11594
+pyedb/dotnet/edb_core/utilities/simulation_setup.py,sha256=admZemUDqwOXg7485556MOH3LEMuayZVEtDCzNq0MWM,12299
 pyedb/dotnet/edb_core/utilities/siwave_simulation_setup.py,sha256=s24jfphD88c1Ru_bN2R-Hl70VdPzusBz7d75oYujtl4,12383
 pyedb/generic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyedb/generic/constants.py,sha256=prWLZH0-SeBIVK6LHZ4SGZFQCofuym2TuQYfdqwhuSQ,28956
@@ -173,7 +173,7 @@ pyedb/misc/siw_feature_config/emc/tag_library.py,sha256=yUK4w3hequU017E2DbkA4KE2
 pyedb/misc/siw_feature_config/emc/xml_generic.py,sha256=55X-V0OxWq-v7FTiDVjaZif8V_2xxsvJlJ8bs9Bf61I,2521
 pyedb/modeler/geometry_operators.py,sha256=iXNGfp3oMAxc6Ij_jatawR9NAKksMfnmWTaoHQVGX80,72699
 pyedb/siwave_core/icepak.py,sha256=WnZ-t8mik7LDY06V8hZFV-TxRZJQWK7bu_8Ichx-oBs,5206
-pyedb-0.15.0.dist-info/LICENSE,sha256=qQWivZ12ETN5l3QxvTARY-QI5eoRRlyHdwLlAj0Bg5I,1089
-pyedb-0.15.0.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
-pyedb-0.15.0.dist-info/METADATA,sha256=S2CnVCGVKwvjhyNatAma3o1zlQaEhjaepHEHSZQYBwA,8336
-pyedb-0.15.0.dist-info/RECORD,,
+pyedb-0.16.0.dist-info/LICENSE,sha256=qQWivZ12ETN5l3QxvTARY-QI5eoRRlyHdwLlAj0Bg5I,1089
+pyedb-0.16.0.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+pyedb-0.16.0.dist-info/METADATA,sha256=VG5dbv6_kD6GH-H56A7aGDCQDTcJgMNSJusDxQ8eTo0,8336
+pyedb-0.16.0.dist-info/RECORD,,