pyedb 0.12.1__py3-none-any.whl → 0.13.0__py3-none-any.whl

pyedb/configuration/cfg_ports_sources.py

@@ -27,7 +27,7 @@ class CfgCircuitElement:
     @property
     def pedb(self):
         """Edb."""
-        return self._pdata.pedb
+        return self._pdata._pedb
 
     @pyedb_function_handler
     def __init__(self, pdata, **kwargs):
@@ -76,7 +76,7 @@ class CfgCircuitElement:
                 search_radius = neg_value.get("search_radius", "5e-3")
                 temp = dict()
                 for i, j in pos_objs.items():
-                    temp[i] = self._pdata.pedb.padstacks.get_reference_pins(j, ref_net, search_radius, max_limit=1)[0]
+                    temp[i] = self._pdata._pedb.padstacks.get_reference_pins(j, ref_net, search_radius, max_limit=1)[0]
                 self.neg_terminal = {
                     i: j.create_terminal(i + "_ref") if not j.terminal else j.terminal for i, j in temp.items()
                 }
@@ -105,7 +105,7 @@ class CfgCircuitElement:
                 pins.update(get_pin_obj(i))
         else:
             if terminal_type == "net":
-                temp = self._pdata.pedb.components.get_pins(self.reference_designator, terminal_value[0])
+                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
@@ -119,7 +119,7 @@ class CfgCircuitElement:
         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)
+        name, temp = self._pdata._pedb.siwave.create_pin_group(self.reference_designator, pin_names, pg_name)
         return {name: temp}
 
 

pyedb/configuration/cfg_s_parameter_models.py

@@ -25,7 +25,7 @@ from pathlib import Path
 
 class CfgSParameterModel:
     def __init__(self, pdata, path_lib, sparam_dict):
-        self._pedb = pdata.pedb
+        self._pedb = pdata._pedb
         self.path_libraries = path_lib
         self._sparam_dict = sparam_dict
         self.name = self._sparam_dict.get("name", "")

pyedb/configuration/cfg_setup.py

@@ -89,7 +89,7 @@ class DcIrSettings:
 
 class CfgSetup:
     def __init__(self, pdata, setup_dict=None):
-        self._pedb = pdata.pedb
+        self._pedb = pdata._pedb
         self._setup_dict = None
         self.name = "PyEDB_setup"
         self.type = self.SetupType.HFSS

pyedb/configuration/cfg_spice_models.py

@@ -25,7 +25,7 @@ from pathlib import Path
 
 class CfgSpiceModel:
     def __init__(self, pdata, path_lib, spice_dict):
-        self._pedb = pdata.pedb
+        self._pedb = pdata._pedb
         self.path_libraries = path_lib
         self._spice_dict = spice_dict
         self.name = self._spice_dict.get("name", "")

pyedb/configuration/cfg_stackup.py

@@ -0,0 +1,169 @@
+# Copyright (C) 2023 - 2024 ANSYS, Inc. and/or its affiliates.
+# SPDX-License-Identifier: MIT
+#
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+from pyedb.configuration.cfg_common import CfgBase
+from pyedb.generic.general_methods import pyedb_function_handler
+
+
+class CfgMaterial(CfgBase):
+    def __init__(self, **kwargs):
+        self.name = kwargs.get("name", None)
+        self.permittivity = kwargs.get("permittivity", None)
+        self.conductivity = kwargs.get("conductivity", None)
+        self.dielectric_loss_tangent = kwargs.get("dielectric_loss_tangent", None)
+        self.magnetic_loss_tangent = kwargs.get("magnetic_loss_tangent", None)
+        self.mass_density = kwargs.get("mass_density", None)
+        self.permeability = kwargs.get("permeability", None)
+        self.poisson_ratio = kwargs.get("poisson_ratio", None)
+        self.specific_heat = kwargs.get("specific_heat", None)
+        self.thermal_conductivity = kwargs.get("thermal_conductivity", None)
+
+
+class CfgLayer(CfgBase):
+    def __init__(self, **kwargs):
+        self.name = kwargs.get("name", None)
+        self.type = kwargs.get("type", None)
+        self.material = kwargs.get("material", None)
+        self.fill_material = kwargs.get("fill_material", None)
+        self.thickness = kwargs.get("thickness", None)
+
+
+class CfgStackup:
+    def __init__(self, pedb, data):
+        self._pedb = pedb
+
+        self.materials = [CfgMaterial(**mat) for mat in data.get("materials", [])]
+        self.layers = [CfgLayer(**lay) for lay in data.get("layers", [])]
+
+    @pyedb_function_handler
+    def apply(self):
+        """Apply configuration settings to the current design"""
+        if len(self.materials):
+            self.__apply_materials()
+
+        input_signal_layers = [i for i in self.layers if i.type.lower() == "signal"]
+
+        if len(self.layers):
+            if len(self._pedb.stackup.signal_layers) == 0:
+                self.__create_stackup()
+            elif not len(input_signal_layers) == len(self._pedb.stackup.signal_layers):
+                raise Exception(f"Input signal layer count do not match.")
+            else:
+                self.__apply_layers()
+
+    def __create_stackup(self):
+        layers = list()
+        layers.extend(self.layers)
+        for l_attrs in layers:
+            attrs = l_attrs.get_attributes()
+            self._pedb.stackup.add_layer_bottom(**attrs)
+
+    @pyedb_function_handler
+    def __apply_layers(self):
+        """Apply layer settings to the current design"""
+        layers = list()
+        layers.extend(self.layers)
+
+        removal_list = []
+        lc_signal_layers = []
+        for name, obj in self._pedb.stackup.all_layers.items():
+            if obj.type == "dielectric":
+                removal_list.append(name)
+            elif obj.type == "signal":
+                lc_signal_layers.append(obj.id)
+        for l in removal_list:
+            self._pedb.stackup.remove_layer(l)
+
+        # update all signal layers
+        id_name = {i[0]: i[1] for i in self._pedb.stackup.layers_by_id}
+        signal_idx = 0
+        for l in layers:
+            if l.type == "signal":
+                layer_id = lc_signal_layers[signal_idx]
+                layer_name = id_name[layer_id]
+                attrs = l.get_attributes()
+                self._pedb.stackup.layers[layer_name].update(**attrs)
+                signal_idx = signal_idx + 1
+
+        # add all dielectric layers. Dielectric layers must be added last. Otherwise,
+        # dielectric layer will occupy signal and document layer id.
+        prev_layer_clone = None
+        l = layers.pop(0)
+        if l.type == "signal":
+            prev_layer_clone = self._pedb.stackup.layers[l.name]
+        else:
+            attrs = l.get_attributes()
+            prev_layer_clone = self._pedb.stackup.add_layer_top(**attrs)
+        for idx, l in enumerate(layers):
+            if l.type == "dielectric":
+                attrs = l.get_attributes()
+                prev_layer_clone = self._pedb.stackup.add_layer_below(base_layer_name=prev_layer_clone.name, **attrs)
+            elif l.type == "signal":
+                prev_layer_clone = self._pedb.stackup.layers[l.name]
+
+    @pyedb_function_handler
+    def __apply_materials(self):
+        """Apply material settings to the current design"""
+        materials_in_db = {i.lower(): i for i, _ in self._pedb.materials.materials.items()}
+        for mat_in_cfg in self.materials:
+            if mat_in_cfg.name.lower() in materials_in_db:
+                self._pedb.materials.delete_material(materials_in_db[mat_in_cfg.name.lower()])
+
+            attrs = mat_in_cfg.get_attributes()
+            mat = self._pedb.materials.add_material(**attrs)
+
+    @pyedb_function_handler
+    def __get_materials_from_db(self):
+        materials = []
+        for name, p in self._pedb.materials.materials.items():
+            mat = {}
+            for p_name in CfgMaterial().__dict__:
+                mat[p_name] = getattr(p, p_name)
+            materials.append(mat)
+        return materials
+
+    @pyedb_function_handler
+    def __get_layers_from_db(self):
+        layers = []
+        for name, obj in self._pedb.stackup.all_layers.items():
+            layer = {}
+            for p_name in CfgLayer().__dict__:
+                p_value = getattr(obj, p_name, None)
+                if p_value is not None:
+                    layer[p_name] = getattr(obj, p_name)
+            layers.append(layer)
+        return layers
+
+    @pyedb_function_handler
+    def get_data_from_db(self):
+        """Get configuration data from layout.
+
+        Returns
+        -------
+        dict
+        """
+        stackup = {}
+        materials = self.__get_materials_from_db()
+        stackup["materials"] = materials
+        layers = self.__get_layers_from_db()
+        stackup["layers"] = layers
+        return stackup

pyedb/configuration/configuration.py

@@ -22,6 +22,7 @@
 
 import json
 import os
+from pathlib import Path
 
 import toml
 
@@ -115,9 +116,7 @@ class Configuration:
             self.cfg_data.nets.apply()
 
         # Configure components
-        if self.cfg_data.components:
-            for comp in self.cfg_data.components:
-                comp.apply()
+        self.cfg_data.components.apply()
 
         # Configure padstacks
         if self.cfg_data.padstacks:
@@ -132,8 +131,6 @@ class Configuration:
             port.create()
 
         # Configure sources
-        """if "sources" in self.data:
-            self._load_sources()"""
         for source in self.cfg_data.sources:
             source.create()
 
@@ -142,8 +139,7 @@ class Configuration:
             setup.apply()
 
         # Configure stackup
-        if "stackup" in self.data:
-            self._load_stackup()
+        self.cfg_data.stackup.apply()
 
         # Configure S-parameter
         for s_parameter_model in self.cfg_data.s_parameters:
@@ -154,12 +150,10 @@ class Configuration:
             spice_model.apply()
 
         # Configure package definitions
-        if "package_definitions" in self.data:
-            self._load_package_def()
+        self.cfg_data.package_definitions.apply()
 
         # Configure operations
-        if "operations" in self.data:
-            self._load_operations()
+        self.cfg_data.operations.apply()
 
         return True
 
@@ -220,14 +214,6 @@ class Configuration:
                 elif l["type"] == "signal":
                     prev_layer_clone = self._pedb.stackup.layers[l["name"]]
 
-    @pyedb_function_handler
-    def _load_operations(self):
-        """Imports operation information from JSON."""
-        operations = self.data["operations"]
-        cutout = operations.get("cutout", None)
-        if cutout:
-            self._pedb.cutout(**cutout)
-
     @pyedb_function_handler
     def _load_package_def(self):
         """Imports package definition information from JSON."""
@@ -271,3 +257,44 @@ class Configuration:
                 )
             for _, i in comp_list.items():
                 i.package_def = name
+
+    def get_data_from_db(self, **kwargs):
+        """Get configuration data from layout.
+
+        Parameters
+        ----------
+        stackup
+
+        Returns
+        -------
+
+        """
+        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()
+
+        return data
+
+    @pyedb_function_handler
+    def export(self, file_path, stackup=True, package_definitions=True):
+        """Export the configuration data from layout to a file.
+
+        Parameters
+        ----------
+        file_path : str, Path
+            File path to export the configuration data.
+        stackup : bool
+            Whether to export stackup or not.
+
+        Returns
+        -------
+        bool
+        """
+        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)
+        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

@@ -27,12 +27,14 @@ This module is implicitly loaded in HFSS 3D Layout when launched.
 """
 from itertools import combinations
 import os
+from pathlib import Path
 import re
 import shutil
 import sys
 import tempfile
 import time
 import traceback
+from typing import Union
 import warnings
 
 from pyedb.configuration.configuration import Configuration
@@ -111,6 +113,8 @@ if is_linux and is_ironpython:
 else:
     import subprocess
 
+import rtree
+
 
 class Edb(Database):
     """Provides the EDB application interface.
@@ -180,7 +184,7 @@ class Edb(Database):
 
     def __init__(
         self,
-        edbpath: str = None,
+        edbpath: Union[str, Path] = None,
         cellname: str = None,
         isreadonly: bool = False,
         edbversion: str = None,
@@ -191,6 +195,9 @@ class Edb(Database):
         technology_file: str = None,
         remove_existing_aedt: bool = False,
     ):
+        if isinstance(edbpath, Path):
+            edbpath = str(edbpath)
+
         edbversion = get_string_version(edbversion)
         self._clean_variables()
         Database.__init__(self, edbversion=edbversion, student_version=student_version)
@@ -315,7 +322,9 @@ class Edb(Database):
             if os.path.isfile(file):
                 if not remove_existing_aedt:
                     self.logger.warning(
-                        f"AEDT project-related file {file} exists and may need to be deleted before opening the EDB in HFSS 3D Layout."  # noqa: E501
+                        f"AEDT project-related file {file} exists and may need to be deleted before opening the EDB in "
+                        f"HFSS 3D Layout."
+                        # noqa: E501
                     )
                 else:
                     try:
@@ -1523,12 +1532,11 @@ class Edb(Database):
             ``True`` when successful, ``False`` when failed.
 
         """
-        if tech_file or map_file:
-            control_file_temp = os.path.join(tempfile.gettempdir(), os.path.split(inputGDS)[-1][:-3] + "xml")
-            ControlFile(xml_input=control_file, tecnhology=tech_file, layer_map=map_file).write_xml(control_file_temp)
-        elif tech_file:
+        if not is_linux and tech_file:
             self.logger.error("Technology files are supported only in Linux. Use control file instead.")
             return False
+        control_file_temp = os.path.join(tempfile.gettempdir(), os.path.split(inputGDS)[-1][:-3] + "xml")
+        ControlFile(xml_input=control_file, tecnhology=tech_file, layer_map=map_file).write_xml(control_file_temp)
         if self.import_layout_pcb(
             inputGDS,
             working_dir=WorkDir,
@@ -4314,7 +4322,7 @@ class Edb(Database):
     @pyedb_function_handler
     def _clean_string_for_variable_name(self, variable_name):
         """Remove forbidden character for variable name.
-        Parameter
+        Parameters
         ----------
         variable_name : str
                 Variable name.
@@ -4331,6 +4339,158 @@ class Edb(Database):
 
         return variable_name
 
+    def create_model_for_arbitrary_wave_ports(
+        self,
+        temp_directory,
+        mounting_side="top",
+        signal_nets=None,
+        terminal_diameter=None,
+        output_edb=None,
+        launching_box_thickness="100um",
+    ):
+        """Generate EDB design to be consumed by PyAEDT to generate arbitrary wave ports shapes.
+        This model has to be considered as merged onto another one. The current opened design must have voids
+        surrounding the pad-stacks where wave ports terminal will be created. THe open design won't be edited, only
+        primitives like voids and pads-stack definition included in the voids are collected to generate a new design.
+
+        Parameters
+        ----------
+        temp_directory : str
+            Temporary directory used during the method execution.
+
+        mounting_side : str
+            Gives the orientation to be considered for the current design. 2 options are available ``"top"`` and
+            ``"bottom". Default value is ``"top"``. If ``"top"`` is selected the method will voids at the top signal
+            layer, and the bottom layer if ``"bottom"`` is used.
+
+        signal_nets : List[str], optional
+            Provides the nets to be included for the model creation. Default value is ``None``. If None is provided,
+            all nets will be included.
+
+        terminal_diameter : float, str, optional
+            When ``None``, the terminal diameter is evaluated at each pads-tack instance found inside the voids. The top
+            or bottom layer pad diameter will be taken, depending on ``mounting_side`` selected. If value is provided,
+            it will overwrite the evaluated diameter.
+
+        output_edb : str, optional
+            The output EDB absolute. If ``None`` the edb is created in the ``temp_directory`` as default name
+            `"waveport_model.aedb"``
+
+        launching_box_thickness : float, str, optional
+            Launching box thickness  used for wave ports. Default value is ``"100um"``.
+
+        Returns
+        -------
+        bool
+            ``True`` when succeeded, ``False`` if failed.
+        """
+        if not temp_directory:
+            self.logger.error("Temp directory must be provided when creating model foe arbitrary wave port")
+            return False
+        if not output_edb:
+            output_edb = os.path.join(temp_directory, "waveport_model.aedb")
+        if os.path.isdir(temp_directory):
+            shutil.rmtree(temp_directory)
+        reference_layer = list(self.stackup.signal_layers.keys())[0]
+        if mounting_side.lower == "bottom":
+            reference_layer = list(self.stackup.signal_layers.keys())[-1]
+        if not signal_nets:
+            signal_nets = list(self.nets.signal.keys())
+
+        used_padstack_defs = []
+        padstack_instances_index = rtree.index.Index()
+        for padstack_inst in list(self.padstacks.instances.values()):
+            if not reference_layer in [padstack_inst.start_layer, padstack_inst.stop_layer]:
+                padstack_inst.delete()
+            else:
+                if padstack_inst.net_name in signal_nets:
+                    padstack_instances_index.insert(padstack_inst.id, padstack_inst.position)
+                    if not padstack_inst.padstack_definition in used_padstack_defs:
+                        used_padstack_defs.append(padstack_inst.padstack_definition)
+
+        polys = [
+            poly
+            for poly in self.modeler.primitives
+            if poly.layer_name == reference_layer and poly.type == "Polygon" and poly.has_voids
+        ]
+        if not polys:
+            self.logger.error(
+                f"No polygon found with voids on layer {reference_layer} during model creation for "
+                f"arbitrary wave ports"
+            )
+            return False
+        void_padstacks = []
+        for poly in polys:
+            for void in poly.voids:
+                void_bbox = (
+                    void.polygon_data.edb_api.GetBBox().Item1.X.ToDouble(),
+                    void.polygon_data.edb_api.GetBBox().Item1.Y.ToDouble(),
+                    void.polygon_data.edb_api.GetBBox().Item2.X.ToDouble(),
+                    void.polygon_data.edb_api.GetBBox().Item2.Y.ToDouble(),
+                )
+                included_instances = list(padstack_instances_index.intersection(void_bbox))
+                if included_instances:
+                    void_padstacks.append((void, [self.padstacks.instances[edb_id] for edb_id in included_instances]))
+
+        if not void_padstacks:
+            self.logger.error(
+                "No padstack instances found inside evaluated voids during model creation for arbitrary" "waveports"
+            )
+            return False
+        cloned_edb = Edb(edbpath=output_edb, edbversion=self.edbversion)
+        cloned_edb.stackup.add_layer(layer_name="ref", layer_type="signal", thickness=0.0, material="pec")
+        cloned_edb.stackup.add_layer(
+            layer_name="ports",
+            layer_type="signal",
+            thickness=self.stackup.signal_layers[reference_layer].thickness,
+            material="pec",
+        )
+        box_thick = "100um"
+        if launching_box_thickness:
+            box_thick = self.edb_value(launching_box_thickness).ToString()
+        if mounting_side == "top":
+            cloned_edb.stackup.add_layer(
+                layer_name="port_pec", layer_type="signal", thickness=box_thick, method="add_on_bottom", material="pec"
+            )
+        else:
+            cloned_edb.stackup.add_layer(
+                layer_name="port_pec", layer_type="signal", thickness=box_thick, method="add_on_top", material="pec"
+            )
+
+        for void_info in void_padstacks:
+            port_poly = cloned_edb.modeler.create_polygon(
+                main_shape=void_info[0].polygon_data.edb_api, layer_name="ref", net_name="GND"
+            )
+            pec_poly = cloned_edb.modeler.create_polygon(
+                main_shape=port_poly.polygon_data.edb_api, layer_name="port_pec", net_name="GND"
+            )
+            pec_poly.scale(1.5)
+
+        for void_info in void_padstacks:
+            for inst in void_info[1]:
+                if not terminal_diameter:
+                    pad_diameter = (
+                        self.padstacks.definitions[inst.padstack_definition]
+                        .pad_by_layer[reference_layer]
+                        .parameters_values[0]
+                    )
+                else:
+                    pad_diameter = self.edb_value(terminal_diameter).ToDouble()
+                _temp_circle = cloned_edb.modeler.create_circle(
+                    layer_name="ports",
+                    x=inst.position[0],
+                    y=inst.position[1],
+                    radius=pad_diameter / 2,
+                    net_name=inst.net_name,
+                )
+                if not _temp_circle:
+                    self.logger.error(
+                        f"Failed to create circle for terminal during create_model_for_arbitrary_wave_ports"
+                    )
+        cloned_edb.save_as(output_edb)
+        cloned_edb.close()
+        return True
+
     @property
     def definitions(self):
         """Definitions class."""

pyedb/dotnet/edb_core/cell/hierarchy/model.py

@@ -20,7 +20,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-from pyedb.dotnet.edb_core.obj_base import ObjBase
+from pyedb.dotnet.edb_core.utilities.obj_base import ObjBase
 from pyedb.generic.general_methods import pyedb_function_handler
 
 

pyedb/dotnet/edb_core/{edb_data/connectable.py → cell/layout_obj.py}

@@ -20,7 +20,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-from pyedb.dotnet.edb_core.obj_base import ObjBase
+from pyedb.dotnet.edb_core.utilities.obj_base import ObjBase
 from pyedb.generic.general_methods import pyedb_function_handler