pyedb 0.41.0__py3-none-any.whl → 0.43.0__py3-none-any.whl

pyedb/configuration/cfg_s_parameter_models.py

@@ -36,81 +36,106 @@ class CfgSParameterModel:
 
 
 class CfgSParameters:
+    class Grpc:
+        def __init__(self, parent):
+            self.parent = parent
+            self._pedb = parent._pedb
+
+        def apply(self):
+            for s_param in self.parent.s_parameters_models:
+                fpath = s_param.file_path
+                if not Path(fpath).anchor:
+                    fpath = str(Path(self.parent.path_libraries) / fpath)
+                comp_def = self._pedb.definitions.component[s_param.component_definition]
+                if s_param.pin_order:
+                    comp_def.set_properties(pin_order=s_param.pin_order)
+                comp_def.add_n_port_model(fpath, s_param.name)
+                comp_list = dict()
+                if s_param.apply_to_all:
+                    comp_list.update(
+                        {
+                            refdes: comp
+                            for refdes, comp in comp_def.components.items()
+                            if refdes not in s_param.components
+                        }
+                    )
+                else:
+                    comp_list.update(
+                        {refdes: comp for refdes, comp in comp_def.components.items() if refdes in s_param.components}
+                    )
+
+                for refdes, comp in comp_list.items():
+                    if refdes in s_param.reference_net_per_component:
+                        ref_net = s_param.reference_net_per_component[refdes]
+                    else:
+                        ref_net = s_param.reference_net
+                    comp.use_s_parameter_model(s_param.name, reference_net=ref_net)
+
+        def get_data_from_db(self, cfg_components):
+            db_comp_def = self._pedb.definitions.component
+            for name, compdef_obj in db_comp_def.items():
+                nport_models = compdef_obj.component_models
+                if not nport_models:
+                    continue
+                else:
+                    pin_order = compdef_obj.get_properties()["pin_order"]
+                    temp_comps = [i for i in cfg_components if i["definition"] == name]
+                    for model_name, model_obj in nport_models.items():
+                        temp_comp_list = []
+                        reference_net_per_component = {}
+                        for i in temp_comps:
+                            s_param_model = i.get("s_parameter_model")
+                            if s_param_model:
+                                if s_param_model["model_name"] == model_name:
+                                    temp_comp_list.append(i["reference_designator"])
+                                    reference_net_per_component[i["reference_designator"]] = s_param_model[
+                                        "reference_net"
+                                    ]
+                            else:
+                                continue
+
+                        self.parent.s_parameters_models.append(
+                            CfgSParameterModel(
+                                name=model_name,
+                                component_definition=name,
+                                file_path=model_obj.reference_file,
+                                apply_to_all=False,
+                                components=temp_comp_list,
+                                reference_net_per_component=reference_net_per_component,
+                                pin_order=pin_order,
+                            )
+                        )
+
+            data = []
+            for i in self.parent.s_parameters_models:
+                data.append(
+                    {
+                        "name": i.name,
+                        "component_definition": i.component_definition,
+                        "file_path": i.file_path,
+                        "apply_to_all": i.apply_to_all,
+                        "components": i.components,
+                        "reference_net_per_component": i.reference_net_per_component,
+                        "pin_order": i.pin_order,
+                    }
+                )
+            return data
+
+    class DotNet(Grpc):
+        def __init__(self, parent):
+            super().__init__(parent)
+
     def __init__(self, pedb, data, path_lib=None):
         self._pedb = pedb
+        if self._pedb.grpc:
+            self.api = self.Grpc(self)
+        else:
+            self.api = self.DotNet(self)
         self.path_libraries = path_lib
         self.s_parameters_models = [CfgSParameterModel(**i) for i in data]
 
     def apply(self):
-        for s_param in self.s_parameters_models:
-            fpath = s_param.file_path
-            if not Path(fpath).anchor:
-                fpath = str(Path(self.path_libraries) / fpath)
-            comp_def = self._pedb.definitions.component[s_param.component_definition]
-            if s_param.pin_order:
-                comp_def.set_properties(pin_order=s_param.pin_order)
-            comp_def.add_n_port_model(fpath, s_param.name)
-            comp_list = dict()
-            if s_param.apply_to_all:
-                comp_list.update(
-                    {refdes: comp for refdes, comp in comp_def.components.items() if refdes not in s_param.components}
-                )
-            else:
-                comp_list.update(
-                    {refdes: comp for refdes, comp in comp_def.components.items() if refdes in s_param.components}
-                )
-
-            for refdes, comp in comp_list.items():
-                if refdes in s_param.reference_net_per_component:
-                    ref_net = s_param.reference_net_per_component[refdes]
-                else:
-                    ref_net = s_param.reference_net
-                comp.use_s_parameter_model(s_param.name, reference_net=ref_net)
+        self.api.apply()
 
     def get_data_from_db(self, cfg_components):
-        db_comp_def = self._pedb.definitions.component
-        for name, compdef_obj in db_comp_def.items():
-            nport_models = compdef_obj.component_models
-            if not nport_models:
-                continue
-            else:
-                pin_order = compdef_obj.get_properties()["pin_order"]
-                temp_comps = [i for i in cfg_components if i["definition"] == name]
-                for model_name, model_obj in nport_models.items():
-                    temp_comp_list = []
-                    reference_net_per_component = {}
-                    for i in temp_comps:
-                        s_param_model = i.get("s_parameter_model")
-                        if s_param_model:
-                            if s_param_model["model_name"] == model_name:
-                                temp_comp_list.append(i["reference_designator"])
-                                reference_net_per_component[i["reference_designator"]] = s_param_model["reference_net"]
-                        else:
-                            continue
-
-                    self.s_parameters_models.append(
-                        CfgSParameterModel(
-                            name=model_name,
-                            component_definition=name,
-                            file_path=model_obj.reference_file,
-                            apply_to_all=False,
-                            components=temp_comp_list,
-                            reference_net_per_component=reference_net_per_component,
-                            pin_order=pin_order,
-                        )
-                    )
-
-        data = []
-        for i in self.s_parameters_models:
-            data.append(
-                {
-                    "name": i.name,
-                    "component_definition": i.component_definition,
-                    "file_path": i.file_path,
-                    "apply_to_all": i.apply_to_all,
-                    "components": i.components,
-                    "reference_net_per_component": i.reference_net_per_component,
-                    "pin_order": i.pin_order,
-                }
-            )
-        return data
+        return self.api.get_data_from_db(cfg_components)

pyedb/configuration/cfg_setup.py

@@ -20,225 +20,270 @@
 # 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 CfgSetup:
+    """
+    Parameters
+    ----------
+    name : str, optional
+    type : str
+        Type of the setup. Optionals are ``"hfss"``, ``"siwave_ac"``, ``"siwave_dc"``.
+
+    """
+
+    class Common:
+        @property
+        def pyedb_obj(self):
+            return self.parent.pyedb_obj
+
+        def __init__(self, parent):
+            self.parent = parent
+            self.pedb = parent.pedb
+
+        def _retrieve_parameters_from_edb_common(self):
+            self.parent.name = self.pyedb_obj.name
+            self.parent.type = self.pyedb_obj.type
+
+        def _apply_freq_sweep(self, edb_setup):
+            for i in self.parent.freq_sweep:
+                f_set = []
+                freq_string = []
+                for f in i.get("frequencies", []):
+                    if isinstance(f, dict):
+                        increment = f.get("increment", f.get("points", f.get("samples", f.get("step"))))
+                        f_set.append([f["distribution"], f["start"], f["stop"], increment])
+                    else:
+                        freq_string.append(f)
+                sweep = edb_setup.add_sweep(i["name"], frequency_set=f_set, sweep_type=i["type"])
+                if len(freq_string) > 0:
+                    sweep.frequency_string = freq_string
 
-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 Grpc(Common):
+        def __init__(self, parent):
+            super().__init__(parent)
 
+        def set_parameters_to_edb(self):
+            pass
 
-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))
+        def retrieve_parameters_from_edb(self):
+            pass
 
+    class DotNet(Grpc):
+        def __init__(self, parent):
+            super().__init__(parent)
 
-class CfgSetup(CfgBase):
-    def __init__(self, pedb, **kwargs):
-        self._pedb = pedb
+    def __init__(self, pedb, pedb_obj, **kwargs):
+        self.pedb = pedb
+        self.pyedb_obj = pedb_obj
         self.name = kwargs.get("name")
-        self.type = kwargs.get("type").lower() if kwargs.get("type") else None
+        self.type = ""
 
         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)
 
+        self.freq_sweep = kwargs.get("freq_sweep", [])
 
-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")
+        if self.pedb.grpc:
+            self.api = self.Grpc(self)
+        else:
+            self.api = self.DotNet(self)
 
-    def apply(self):
-        if self.name in self._pedb.setups:
-            raise "Setup {} already existing. Editing it.".format(self.name)
+    def _to_dict_setup(self):
+        return {
+            "name": self.name,
+            "type": self.type,
+        }
 
-        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 CfgSIwaveACSetup(CfgSetup):
+    class Grpc(CfgSetup.Common):
+        def __init__(self, parent):
+            super().__init__(parent)
 
-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 set_parameters_to_edb(self):
+            if self.parent.name in self.pedb.setups:
+                raise "Setup {} already existing. Editing it.".format(self.parent.name)
 
-    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
+            edb_setup = self.pedb.create_siwave_syz_setup(name=self.parent.name)
+            if self.parent.si_slider_position is not None:
+                edb_setup.si_slider_position = self.parent.si_slider_position
             else:
-                setattr(edb_setup.dc_ir_settings, k, v)
-
-
-class CfgHFSSSetup(CfgSetup):
-    def __init__(self, pedb, **kwargs):
-        super().__init__(pedb, **kwargs)
+                edb_setup.pi_slider_position = self.parent.pi_slider_position
+            self._apply_freq_sweep(edb_setup)
+
+        def retrieve_parameters_from_edb(self):
+            self._retrieve_parameters_from_edb_common()
+            self.parent.use_si_settings = self.pyedb_obj.use_si_settings
+            self.parent.si_slider_position = self.pyedb_obj.si_slider_position
+            self.parent.pi_slider_position = self.pyedb_obj.pi_slider_position
+
+    class DotNet(Grpc):
+        def __init__(self, parent):
+            super().__init__(parent)
+
+    def __init__(self, pedb, pyedb_obj, **kwargs):
+        super().__init__(pedb, pyedb_obj, **kwargs)
+        self.type = "siwave_ac"
+        self.use_si_settings = kwargs.get("use_si_settings", True)
+        self.si_slider_position = kwargs.get("si_slider_position", 1)
+        self.pi_slider_position = kwargs.get("pi_slider_position", 1)
+
+    def to_dict(self):
+        temp = self._to_dict_setup()
+        temp.update(
+            {
+                "use_si_settings": self.use_si_settings,
+                "si_slider_position": self.si_slider_position,
+                "pi_slider_position": self.pi_slider_position,
+            }
+        )
+        return temp
 
-        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))
+class CfgSIwaveDCSetup(CfgSetup):
+    class Grpc(CfgSetup.Common):
+        def __init__(self, parent):
+            super().__init__(parent)
 
-    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
+        def set_parameters_to_edb(self):
+            edb_setup = self.pedb.create_siwave_dc_setup(
+                name=self.parent.name, dc_slider_position=self.parent.dc_slider_position
             )
+            edb_setup.dc_settings.dc_slider_position = self.parent.dc_slider_position
+            dc_ir_settings = self.parent.dc_ir_settings
+            edb_setup.dc_ir_settings.export_dc_thermal_data = dc_ir_settings["export_dc_thermal_data"]
+
+        def retrieve_parameters_from_edb(self):
+            self._retrieve_parameters_from_edb_common()
+            self.parent.dc_slider_position = self.pyedb_obj.dc_settings.dc_slider_position
+            dc_ir_settings = dict()
+            dc_ir_settings["export_dc_thermal_data"] = self.pyedb_obj.dc_ir_settings.export_dc_thermal_data
+            self.parent.dc_ir_settings = dc_ir_settings
+
+    class DotNet(Grpc):
+        def __init__(self, parent):
+            super().__init__(parent)
+
+    def __init__(self, pedb, pyedb_obj, **kwargs):
+        super().__init__(pedb, pyedb_obj, **kwargs)
+        self.type = "siwave_dc"
+        self.dc_slider_position = kwargs.get("dc_slider_position")
+        self.dc_ir_settings = kwargs.get("dc_ir_settings", {})
 
+    def to_dict(self):
+        temp = self._to_dict_setup()
+        temp.update({"dc_slider_position": self.dc_slider_position, "dc_ir_settings": self.dc_ir_settings})
+        return temp
 
-class CfgDcIrSettings(CfgBase):
-    def __init__(self, **kwargs):
-        self.export_dc_thermal_data = kwargs.get("export_dc_thermal_data")
 
+class CfgHFSSSetup(CfgSetup):
+    class Grpc(CfgSetup.Common):
+        def __init__(self, parent):
+            super().__init__(parent)
 
-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)
+        def set_parameters_to_edb(self):
+            if self.parent.name in self.pedb.setups:
+                raise "Setup {} already existing. Editing it.".format(self.parent.name)
 
+            edb_setup = self.pedb.create_hfss_setup(self.parent.name)
+            edb_setup.set_solution_single_frequency(
+                self.parent.f_adapt, self.parent.max_num_passes, self.parent.max_mag_delta_s
+            )
 
-class CfgLengthMeshOperation(CfgMeshOperation):
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
+            self._apply_freq_sweep(edb_setup)
+
+            for i in self.parent.mesh_operations:
+                edb_setup.add_length_mesh_operation(
+                    name=i["name"],
+                    max_elements=i.get("max_elements", 1000),
+                    max_length=i.get("max_length", "1mm"),
+                    restrict_length=i.get("restrict_length", True),
+                    refine_inside=i.get("refine_inside", False),
+                    # mesh_region=i.get(mesh_region),
+                    net_layer_list=i.get("nets_layers_list", {}),
+                )
+
+        def retrieve_parameters_from_edb(self):
+            self._retrieve_parameters_from_edb_common()
+            adaptive_frequency_data_list = list(self.pyedb_obj.adaptive_settings.adaptive_frequency_data_list)[0]
+            self.parent.f_adapt = adaptive_frequency_data_list.adaptive_frequency
+            self.parent.max_num_passes = adaptive_frequency_data_list.max_passes
+            self.parent.max_mag_delta_s = adaptive_frequency_data_list.max_delta
+            self.parent.freq_sweep = []
+            for name, sw in self.pyedb_obj.sweeps.items():
+                self.parent.freq_sweep.append({"name": name, "type": sw.type, "frequencies": sw.frequency_string})
+
+            self.parent.mesh_operations = []
+            for name, mop in self.pyedb_obj.mesh_operations.items():
+                self.parent.mesh_operations.append(
+                    {
+                        "name": name,
+                        "type": mop.type,
+                        "max_elements": mop.max_elements,
+                        "max_length": mop.max_length,
+                        "restrict_length": mop.restrict_length,
+                        "refine_inside": mop.refine_inside,
+                        "nets_layers_list": mop.nets_layers_list,
+                    }
+                )
+
+    class DotNet(Grpc):
+        def __init__(self, parent):
+            super().__init__(parent)
+
+    def __init__(self, pedb, pyedb_obj, **kwargs):
+        super().__init__(pedb, pyedb_obj, **kwargs)
+        self.type = "hfss"
+        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")
 
-        # 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")
+        self.mesh_operations = kwargs.get("mesh_operations", [])
+
+    def to_dict(self):
+        temp = self._to_dict_setup()
+        temp.update(
+            {
+                "f_adapt": self.f_adapt,
+                "max_num_passes": self.max_num_passes,
+                "max_mag_delta_s": self.max_mag_delta_s,
+                "mesh_operations": self.mesh_operations,
+                "freq_sweep": self.freq_sweep,
+            }
+        )
+        return temp
 
 
 class CfgSetups:
     def __init__(self, pedb, setups_data):
-        self._pedb = pedb
+        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))
+            if stp["type"].lower() == "hfss":
+                self.setups.append(CfgHFSSSetup(self.pedb, None, **stp))
+            elif stp["type"].lower() in ["siwave_ac", "siwave_syz"]:
+                self.setups.append(CfgSIwaveACSetup(self.pedb, None, **stp))
+            elif stp["type"].lower() == "siwave_dc":
+                self.setups.append(CfgSIwaveDCSetup(self.pedb, None, **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():
-            if float(self._pedb.edbversion) < 2025.1:
-                if not s.type == "hfss":
-                    self._pedb.logger.warning("Only HFSS setups are exported in 2024 R2 and earlier version.")
-                    continue
-
-            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
+            s.api.set_parameters_to_edb()
+
+    def to_dict(self):
+        return [i.to_dict() for i in self.setups]
+
+    def retrieve_parameters_from_edb(self):
+        self.setups = []
+        for _, setup in self.pedb.setups.items():
+            if setup.type == "hfss":
+                hfss = CfgHFSSSetup(self.pedb, setup)
+                hfss.api.retrieve_parameters_from_edb()
+                self.setups.append(hfss)
+            elif setup.type == "siwave_dc":
+                siwave_dc = CfgSIwaveDCSetup(self.pedb, setup)
+                siwave_dc.api.retrieve_parameters_from_edb()
+                self.setups.append(siwave_dc)
+            elif setup.type == "siwave_ac":
+                siwave_ac = CfgSIwaveACSetup(self.pedb, setup)
+                siwave_ac.api.retrieve_parameters_from_edb()
+                self.setups.append(siwave_ac)