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

pyedb/__init__.py

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

pyedb/configuration/cfg_data.py

@@ -0,0 +1,45 @@
+# 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_ports import CfgPort
+
+
+class CfgData(object):
+    """Manages configure data."""
+
+    def __init__(self, pedb, **kwargs):
+        self.pedb = pedb
+        self.edb_comps = self.pedb.components.components
+
+        self.cfg_general = None
+        self.cfg_boundaries = None
+        self.cfg_nets = None
+        self.cfg_components = None
+        self.cfg_padstacks = None
+        self.cfg_pin_groups = None
+        self.cfg_ports = [CfgPort(self, **port) for port in kwargs.get("ports", [])]
+        self.cfg_setups = None
+        self.cfg_stackup = None
+        self.cfg_s_parameters = None
+        self.cfg_spice_models = None
+        self.cfg_package_definition = None
+        self.cfg_operations = None

pyedb/configuration/cfg_ports.py

@@ -0,0 +1,149 @@
+# 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
+
+from pyedb.dotnet.edb_core.edb_data.padstacks_data import EDBPadstackInstance
+
+
+class CfgNegTerm:
+    """Manage negative terminal."""
+
+    class CfgTermType(Enum):
+        """Terminal types."""
+
+        pin = [list, str]
+        net = [str]
+        pin_group = [str]
+
+    @property
+    def pedb(self):
+        """Edb."""
+        return self.pport.pedb
+
+    def __init__(self, pport, **kwargs):
+        self.pport = pport
+        self.type = kwargs.get("type", None)
+        self.value = kwargs.get("value", None)
+
+    def _get_candidates(self, distributed):
+        """Get list of objects."""
+
+        def get_pin_obj(pin_name):
+            port_name = "{}_{}".format(self.pport.reference_designator, pin_name)
+            return {port_name: self.pport.pdata.edb_comps[self.pport.reference_designator].pins[pin_name]}
+
+        def get_pin_group_obj(pin_group_name):
+            pin_group_obj = self.pedb.siwave.pin_groups[pin_group_name]
+            return {pin_group_obj.name: pin_group_obj}
+
+        term_objs = dict()
+        if self.type in "pin":
+            term_objs.update(get_pin_obj(self.value))
+        elif self.type == "pin_group":
+            term_objs.update(get_pin_group_obj(self.value))
+        elif self.type == "net":
+            pins = self.pport.pdata.pedb.components.get_pin_from_component(self.pport.reference_designator, self.value)
+            pins = [EDBPadstackInstance(p, self.pedb) for p in pins]
+
+            pin_objs = {f"{self.value}_{p.GetName()}": p for p in pins}
+            if distributed:
+                term_objs.update(pin_objs)
+            else:
+                pg_name = f"pg_{self.pport.reference_designator}_{self.value}"
+                pin_objs = {p.GetName(): p for p in pin_objs.values()}
+                if self.pport.type == "coax":
+                    term_objs.update(get_pin_obj(pins[0].GetName()))
+                else:
+                    temp = self.pport.pdata.pedb.siwave.create_pin_group(
+                        self.pport.reference_designator, list(pin_objs.keys()), pg_name
+                    )
+                    term_objs.update({temp[0]: temp[1]})
+        return term_objs
+
+    def get_candidates(self):
+        """Get list of objects."""
+        return self._get_candidates(False)
+
+
+class CfgPosTerm(CfgNegTerm):
+    """Manage positive terminal."""
+
+    def __init__(self, pport, **kwargs):
+        super().__init__(pport, **kwargs)
+
+    def get_candidates(self):
+        """Get list of objects."""
+        return self._get_candidates(self.pport.distributed)
+
+
+class CfgPort:
+    """Manage port."""
+
+    class CfgPortType(Enum):
+        """Port type."""
+
+        circuit = [str]
+        coax = [str]
+
+    @property
+    def pedb(self):
+        """Edb."""
+        return self.pdata.pedb
+
+    def __init__(self, pdata, **kwargs):
+        self.pdata = pdata
+        self.name = kwargs.get("name", None)
+        self.type = kwargs.get("type", None)
+        self.reference_designator = kwargs.get("reference_designator", None)
+        pos_term = kwargs.get("positive_terminal", None)
+        neg_term = kwargs.get("negative_terminal", None)
+        if pos_term:
+            self.positive_terminal = CfgPosTerm(
+                pport=self, type=list(pos_term.keys())[0], value=list(pos_term.values())[0]
+            )
+        if neg_term:
+            self.negative_terminal = CfgPosTerm(
+                pport=self, type=list(neg_term.keys())[0], value=list(neg_term.values())[0]
+            )
+        self.distributed = kwargs.get("distributed", False)
+
+        self._port_name = None
+
+    def create(self):
+        """Create port."""
+        if self.type == "circuit":
+            candidates = [i for i in self.negative_terminal.get_candidates().values()][0]
+            neg_term = candidates.get_terminal(create_new_terminal=True)
+        else:
+            neg_term = None
+        ports = []
+        for name, p in self.positive_terminal.get_candidates().items():
+            if self.distributed:
+                port_name = f"{self.name}_{name}" if self.name else name
+            else:
+                port_name = self.name if self.name else name
+            pos_term = p.get_terminal(port_name, create_new_terminal=True)
+            is_circuit_port = True if self.type == "circuit" else False
+            port = self.pedb.create_port(pos_term, neg_term, is_circuit_port)
+            ports.append(port)
+        return ports

pyedb/{dotnet/edb_core → configuration}/configuration.py

@@ -26,6 +26,7 @@ from pathlib import Path
 
 import toml
 
+from pyedb.configuration.cfg_data import CfgData
 from pyedb.dotnet.edb_core.definition.package_def import PackageDef
 from pyedb.generic.general_methods import pyedb_function_handler
 
@@ -39,6 +40,7 @@ class Configuration:
         self.data = {}
         self._s_parameter_library = ""
         self._spice_model_library = ""
+        self.cfg_data = None
 
     @pyedb_function_handler
     def load(self, config_file, append=True, apply_file=False, output_file=None, open_at_the_end=True):
@@ -86,6 +88,9 @@ class Configuration:
                     self.data[k] = v
             else:
                 self.data[k] = v
+
+        self.cfg_data = CfgData(self._pedb, **data)
+
         if apply_file:
             original_file = self._pedb.edbpath
             if output_file:
@@ -132,8 +137,8 @@ class Configuration:
             self._load_pin_groups()
 
         # Configure ports
-        if "ports" in self.data:
-            self._load_ports()
+        for port in self.cfg_data.cfg_ports:
+            port.create()
 
         # Configure sources
         if "sources" in self.data:
@@ -275,6 +280,7 @@ class Configuration:
     @pyedb_function_handler
     def _load_ports(self):
         """Imports port information from json."""
+
         for port in self.data["ports"]:
             port_type = port["type"]
 
@@ -315,7 +321,7 @@ class Configuration:
                     pin_name = negative_terminal_json["pin"]
                     port_name = "{}_{}_ref".format(ref_designator, pin_name)
                     neg_terminal = comp_layout.pins[pin_name].get_terminal(port_name, True)
-                else:
+                elif "net" in negative_terminal_json:
                     net_name = negative_terminal_json["net"]
                     port_name = "{}_{}_ref".format(ref_designator, net_name)
                     pg_name = "pg_{}".format(port_name)
@@ -476,35 +482,65 @@ class Configuration:
     def _load_stackup(self):
         """Imports stackup information from json."""
         data = self.data["stackup"]
-        materials = data["materials"] if "materials" in data else []
-        materials_reformatted = {}
-        for mat in materials:
-            new_mat = {}
-            new_mat["name"] = mat["name"]
-            if "conductivity" in mat:
-                new_mat["conductivity"] = mat["conductivity"]
-            if "permittivity" in mat:
-                new_mat["permittivity"] = mat["permittivity"]
-            if "dielectricLoss_tangent" in mat:
-                new_mat["loss_tangent"] = mat["dielectricLoss_tangent"]
-
-            materials_reformatted[mat["name"]] = new_mat
-
-        layers = data["layers"]
-        layers_reformatted = {}
-
-        for l in layers:
-            lyr = {
-                "name": l["name"],
-                "type": l["type"],
-                "material": l["material"],
-                "thickness": l["thickness"],
-            }
-            if "fill_material" in l:
-                lyr["dielectric_fill"] = l["fill_material"]
-            layers_reformatted[l["name"]] = lyr
-        stackup_reformated = {"layers": layers_reformatted, "materials": materials_reformatted}
-        self._pedb.stackup.load(stackup_reformated)
+        materials = data.get("materials")
+
+        if materials:
+            edb_materials = {i.lower(): i for i, _ in self._pedb.materials.materials.items()}
+            for mat in materials:
+                name = mat["name"].lower()
+                if name in edb_materials:
+                    self._pedb.materials.delete_material(edb_materials[name])
+            for mat in materials:
+                self._pedb.materials.add_material(**mat)
+
+        layers = data.get("layers")
+
+        if layers:
+            lc = self._pedb.stackup
+            input_signal_layers = [i for i in layers if i["type"].lower() == "signal"]
+            if not len(input_signal_layers) == len(lc.signal_layers):
+                self._pedb.logger.error("Input signal layer count do not match.")
+                return False
+
+            layer_clones = []
+            doc_layer_clones = []
+            for name, obj in lc.layers.items():
+                if obj.is_stackup_layer:
+                    if obj.type == "signal":  # keep signal layers
+                        layer_clones.append(obj)
+                else:
+                    doc_layer_clones.append(obj)
+                lc.remove_layer(name)
+
+            signal_layer_ids = {}
+            top_layer_clone = None
+
+            # add all signal layers
+            for l in layers:
+                if l["type"] == "signal":
+                    clone = layer_clones.pop(0)
+                    clone.update(**l)
+                    lc.add_layer_bottom(name=clone.name, layer_clone=clone)
+                    signal_layer_ids[clone.name] = clone.id
+
+            # add all document layers at bottom
+            for l in doc_layer_clones:
+                doc_layer = lc.add_document_layer(name=l.name, layer_clone=l)
+                first_doc_layer_name = doc_layer.name
+
+            # 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 = lc.layers[l["name"]]
+            else:
+                prev_layer_clone = lc.add_layer_top(**l)
+            for idx, l in enumerate(layers):
+                if l["type"] == "dielectric":
+                    prev_layer_clone = lc.add_layer_below(base_layer_name=prev_layer_clone.name, **l)
+                else:
+                    prev_layer_clone = lc.layers[l["name"]]
 
     @pyedb_function_handler
     def _load_s_parameter(self):

pyedb/dotnet/edb.py

@@ -35,9 +35,9 @@ import time
 import traceback
 import warnings
 
+from pyedb.configuration.configuration import Configuration
 from pyedb.dotnet.application.Variables import decompose_variable_value
 from pyedb.dotnet.edb_core.components import Components
-from pyedb.dotnet.edb_core.configuration import Configuration
 from pyedb.dotnet.edb_core.dotnet.database import Database
 from pyedb.dotnet.edb_core.dotnet.layout import LayoutDotNet
 from pyedb.dotnet.edb_core.edb_data.control_file import (
@@ -342,7 +342,7 @@ class Edb(Database):
     @pyedb_function_handler()
     def _init_objects(self):
         self._components = Components(self)
-        self._stackup = Stackup(self)
+        self._stackup = Stackup(self, self.layout.layer_collection)
         self._padstack = EdbPadstacks(self)
         self._siwave = EdbSiwave(self)
         self._hfss = EdbHfss(self)
@@ -845,7 +845,7 @@ class Edb(Database):
         >>> edbapp.stackup.add_layer("Diel", "GND", layer_type="dielectric", thickness="0.1mm", material="FR4_epoxy")
         """
         if not self._stackup2 and self.active_db:
-            self._stackup2 = Stackup(self)
+            self._stackup2 = Stackup(self, self.layout.layer_collection)
         return self._stackup2
 
     @property
@@ -3655,6 +3655,7 @@ class Edb(Database):
         elif not name:
             name = generate_unique_name("setup")
         setup = HfssSimulationSetup(self).create(name)
+        setup.set_solution_single_frequency("1GΗz")
         return setup
 
     def create_raptorx_setup(self, name=None):

pyedb/dotnet/edb_core/components.py

@@ -915,6 +915,12 @@ class Components(object):
         """
         if isinstance(component, str):
             component = self.instances[component].edbcomponent
+        if not solder_balls_height:
+            solder_balls_height = self.components[component.GetName()].solder_ball_height
+        if not solder_balls_size:
+            solder_balls_size = self.components[component.GetName()].solder_ball_diameter[0]
+        if not solder_balls_mid_size:
+            solder_balls_mid_size = self.components[component.GetName()].solder_ball_diameter[1]
         if not isinstance(net_list, list):
             net_list = [net_list]
         for net in net_list:
@@ -2402,20 +2408,20 @@ class Components(object):
         return [pin_xy.X.ToDouble(), pin_xy.Y.ToDouble()]
 
     @pyedb_function_handler()
-    def get_pins_name_from_net(self, pin_list, net_name):
+    def get_pins_name_from_net(self, net_name, pin_list=None):
         """Retrieve pins belonging to a net.
 
         Parameters
         ----------
-        pin_list : list
-            List of pins to check.
+        pin_list : list of EDBPadstackInstance, optional
+            List of pins to check. The default is ``None``, in which case all pins are checked
         net_name : str
             Name of the net.
 
         Returns
         -------
-        list
-            List of pins belong to the net.
+        list of str names:
+            Pins belonging to the net.
 
         Examples
         --------
@@ -2425,11 +2431,16 @@ class Components(object):
         >>> edbapp.components.get_pins_name_from_net(pin_list, net_name)
 
         """
-        pinlist = []
+        pin_names = []
+        if not pin_list:
+            pin_list = []
+            for i in [*self.components.values()]:
+                for j in [*i.pins.values()]:
+                    pin_list.append(j)
         for pin in pin_list:
             if pin.GetNet().GetName() == net_name:
-                pinlist.append(pin.GetName())
-        return pinlist
+                pin_names.append(self.get_aedt_pin_name(pin))
+        return pin_names
 
     @pyedb_function_handler()
     def get_nets_from_pin_list(self, PinList):

pyedb/dotnet/edb_core/edb_data/hfss_simulation_setup_data.py

@@ -29,6 +29,10 @@ from pyedb.dotnet.edb_core.utilities.simulation_setup import (
 from pyedb.generic.general_methods import generate_unique_name, pyedb_function_handler
 
 
+class AdaptiveType(object):
+    (SingleFrequency, MultiFrequency, BroadBand) = range(0, 3)
+
+
 class MeshOperation(object):
     """Mesh Operation Class."""