pyedb 0.10.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

pyedb/configuration/cfg_ports_sources.py

@@ -0,0 +1,164 @@
+# Copyright (C) 2023 - 2024 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+from pyedb.generic.general_methods import pyedb_function_handler
+
+
+class CfgCircuitElement:
+    @property
+    def pedb(self):
+        """Edb."""
+        return self._pdata.pedb
+
+    @pyedb_function_handler
+    def __init__(self, pdata, **kwargs):
+        self._pdata = pdata
+        self._data = kwargs
+        self.name = kwargs.get("name", None)
+        self.type = kwargs.get("type", None)
+        self.reference_designator = kwargs.get("reference_designator", None)
+        self.distributed = kwargs.get("distributed", False)
+        self.pos_term_info = kwargs.get("positive_terminal", None)  # {"pin" : "A1"}
+        self.neg_term_info = kwargs.get("negative_terminal", None)
+
+    @pyedb_function_handler
+    def _create(self):
+        """Create step 1."""
+        pos_term_info = self.pos_term_info
+        if pos_term_info:
+            pos_type, pos_value = [[i, j] for i, j in pos_term_info.items()][0]
+            pos_objs = dict()
+            if self.type == "coax":
+                pins = self._get_pins(pos_type, pos_value)
+                pins = {f"{self.name}_{self.reference_designator}": i for _, i in pins.items()}
+                pos_objs.update(pins)
+            elif pos_type == "pin_group":
+                pos_objs[pos_value] = self.pedb.siwave.pin_groups[pos_value]
+            elif not self.distributed:
+                # get pins
+                pins = self._get_pins(pos_type, pos_value)  # terminal type pin or net
+                # create pin group
+                pin_group = self._create_pin_group(pins)
+                pos_objs.update(pin_group)
+            else:
+                # get pins
+                pins = self._get_pins(pos_type, pos_value)  # terminal type pin or net or pin group
+                pos_objs.update(pins)
+                self._elem_num = len(pos_objs)
+
+            self.pos_terminals = {i: j.create_terminal(i) for i, j in pos_objs.items()}
+
+        neg_term_info = self.neg_term_info
+        self.neg_terminal = None
+        if neg_term_info:
+            neg_type, neg_value = [[i, j] for i, j in neg_term_info.items()][0]
+            if neg_type == "pin_group":
+                pin_group = {neg_value: self.pedb.siwave.pin_groups[neg_value]}
+            else:
+                # Get pins
+                pins = self._get_pins(neg_type, neg_value)  # terminal type pin or net
+                # create pin group
+                pin_group = self._create_pin_group(pins, True)
+            self.neg_terminal = [j.create_terminal(i) if not j.terminal else j.terminal for i, j in pin_group.items()][
+                0
+            ]
+
+    @pyedb_function_handler
+    def _get_pins(self, terminal_type, terminal_value):
+        terminal_value = terminal_value if isinstance(terminal_value, list) else [terminal_value]
+
+        def get_pin_obj(pin_name):
+            return {pin_name: self._pdata.edb_comps[self.reference_designator].pins[pin_name]}
+
+        pins = dict()
+        if terminal_type == "pin":
+            for i in terminal_value:
+                pins.update(get_pin_obj(i))
+        else:
+            if terminal_type == "net":
+                temp = self._pdata.pedb.components.get_pins(self.reference_designator, terminal_value[0])
+            elif terminal_type == "pin_group":
+                pin_group = self.pedb.siwave.pin_groups[terminal_value[0]]
+                temp = pin_group.pins
+            pins.update({f"{self.reference_designator}_{terminal_value[0]}_{i}": j for i, j in temp.items()})
+        return pins
+
+    @pyedb_function_handler
+    def _create_pin_group(self, pins, is_ref=False):
+        if is_ref:
+            pg_name = f"pg_{self.name}_{self.reference_designator}_ref"
+        else:
+            pg_name = f"pg_{self.name}_{self.reference_designator}"
+        pin_names = [i.pin_number for i in pins.values()]
+        name, temp = self._pdata.pedb.siwave.create_pin_group(self.reference_designator, pin_names, pg_name)
+        return {name: temp}
+
+
+class CfgPort(CfgCircuitElement):
+    """Manage port."""
+
+    CFG_PORT_TYPE = {"circuit": [str], "coax": [str]}
+
+    @pyedb_function_handler
+    def __init__(self, pdata, **kwargs):
+        super().__init__(pdata, **kwargs)
+
+    @pyedb_function_handler
+    def create(self):
+        """Create port."""
+        self._create()
+        is_circuit_port = True if self.type == "circuit" else False
+        circuit_elements = []
+        for _, j in self.pos_terminals.items():
+            elem = self.pedb.create_port(j, self.neg_terminal, is_circuit_port)
+            if not self.distributed:
+                elem.name = self.name
+            circuit_elements.append(elem)
+        return circuit_elements
+
+
+class CfgSources(CfgCircuitElement):
+    CFG_SOURCE_TYPE = {"current": [int, float], "voltage": [int, float]}
+
+    @pyedb_function_handler
+    def __init__(self, pdata, **kwargs):
+        super().__init__(pdata, **kwargs)
+
+        self.magnitude = kwargs.get("magnitude", 0.001)
+
+    @pyedb_function_handler
+    def create(self):
+        """Create sources."""
+        self._create()
+        is_circuit_port = True if self.type == "circuit" else False
+        circuit_elements = []
+        method = self.pedb.create_current_source if self.type == "current" else self.pedb.create_voltage_source
+        for _, j in self.pos_terminals.items():
+            elem = method(j, self.neg_terminal)
+            if not self.distributed:
+                elem.name = self.name
+                elem.magnitude = self.magnitude
+            else:
+                elem.name = f"{self.name}_{elem.name}"
+                elem.magnitude = self.magnitude / self._elem_num
+            circuit_elements.append(elem)
+        return circuit_elements

pyedb/configuration/cfg_s_parameter_models.py

@@ -0,0 +1,60 @@
+# Copyright (C) 2023 - 2024 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+from pathlib import Path
+
+
+class CfgSParameterModel:
+    def __init__(self, pdata, path_lib, sparam_dict):
+        self._pedb = pdata.pedb
+        self.path_libraries = path_lib
+        self._sparam_dict = sparam_dict
+        self.name = self._sparam_dict.get("name", "")
+        self.component_definition = self._sparam_dict.get("component_definition", "")
+        self.file_path = self._sparam_dict.get("file_path", "")
+        self.apply_to_all = self._sparam_dict.get("apply_to_all", False)
+        self.components = self._sparam_dict.get("components", [])
+        self.reference_net = self._sparam_dict.get("reference_net", "")
+        self.reference_net_per_component = self._sparam_dict.get("reference_net_per_component", {})
+
+    def apply(self):
+        fpath = self.file_path
+        if not Path(fpath).anchor:
+            fpath = str(Path(self.path_libraries) / fpath)
+        comp_def = self._pedb.definitions.component[self.component_definition]
+        comp_def.add_n_port_model(fpath, self.name)
+        comp_list = dict()
+        if self.apply_to_all:
+            comp_list.update(
+                {refdes: comp for refdes, comp in comp_def.components.items() if refdes not in self.components}
+            )
+        else:
+            comp_list.update(
+                {refdes: comp for refdes, comp in comp_def.components.items() if refdes in self.components}
+            )
+
+        for refdes, comp in comp_list.items():
+            if refdes in self.reference_net_per_component:
+                ref_net = self.reference_net_per_component[refdes]
+            else:
+                ref_net = self.reference_net
+            comp.use_s_parameter_model(self.name, reference_net=ref_net)

pyedb/configuration/cfg_setup.py

@@ -0,0 +1,201 @@
+# Copyright (C) 2023 - 2024 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+from enum import Enum
+
+
+class 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
+
+    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))
+            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)

pyedb/configuration/cfg_spice_models.py

@@ -0,0 +1,49 @@
+# Copyright (C) 2023 - 2024 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+from pathlib import Path
+
+
+class CfgSpiceModel:
+    def __init__(self, pdata, path_lib, spice_dict):
+        self._pedb = pdata.pedb
+        self.path_libraries = path_lib
+        self._spice_dict = spice_dict
+        self.name = self._spice_dict.get("name", "")
+        self.component_definition = self._spice_dict.get("component_definition", "")
+        self.file_path = self._spice_dict.get("file_path", "")
+        self.sub_circuit_name = self._spice_dict.get("sub_circuit_name", "")
+        self.apply_to_all = self._spice_dict.get("apply_to_all", True)
+        self.components = list(self._spice_dict.get("components", []))
+
+    def apply(self):
+        """Apply Spice model on layout."""
+        if not Path(self.file_path).anchor:
+            fpath = str(Path(self.path_libraries) / self.file_path)
+            comps = self._pedb.components.definitions[self.component_definition].components
+            if self.apply_to_all:
+                for ref_des, comp in comps.items():
+                    comp.assign_spice_model(fpath, self.name, self.sub_circuit_name)
+            else:
+                for ref_des, comp in comps.items():
+                    if ref_des in self.components:
+                        comp.assign_spice_model(fpath, self.name, self.sub_circuit_name)