pyedb 0.7.0__py3-none-any.whl → 0.7.1__py3-none-any.whl

pyedb/dotnet/edb_core/padstack.py

@@ -212,7 +212,7 @@ class EdbPadstacks(object):
 
         Returns
         -------
-        dict[str, :class:`dotnet.edb_core.edb_data.padstacks_data.EDBPadstackInstance`]
+        dict[int, :class:`dotnet.edb_core.edb_data.padstacks_data.EDBPadstackInstance`]
             List of padstack instances.
 
         """
@@ -223,6 +223,24 @@ class EdbPadstacks(object):
             padstack_instances[edb_padstack_instance.GetId()] = EDBPadstackInstance(edb_padstack_instance, self._pedb)
         return padstack_instances
 
+    @property
+    def instances_by_name(self):
+        """Dictionary  of all padstack instances (vias and pins) by name.
+
+        Returns
+        -------
+        dict[str, :class:`dotnet.edb_core.edb_data.padstacks_data.EDBPadstackInstance`]
+            List of padstack instances.
+
+        """
+        padstack_instances = {}
+        for _, edb_padstack_instance in self._pedb.padstacks.instances.items():
+            if edb_padstack_instance.aedt_name:
+                padstack_instances[edb_padstack_instance.aedt_name] = EDBPadstackInstance(
+                    edb_padstack_instance, self._pedb
+                )
+        return padstack_instances
+
     @property
     def pins(self):
         """Dictionary  of all pins instances (belonging to component).
@@ -1332,6 +1350,42 @@ class EdbPadstacks(object):
         self.definitions[padstack_name].edb_padstack.SetData(new_padstack_def)
         return True
 
+    @pyedb_function_handler()
+    def get_instances(self, name=None, pid=None, definition_name=None, net_name=None):
+        """Get padstack instances by conditions.
+
+        Parameters
+        ----------
+        name : str, optional
+            Name of the padstack.
+        pid : int, optional
+            Id of the padstack.
+        definition_name : str, list, optional
+            Name of the padstack definition.
+        net_name : str, optional
+            The net name to be used for filtering padstack instances.
+
+        Returns
+        -------
+        list
+            List of :class:`dotnet.edb_core.edb_data.padstacks_data.EDBPadstackInstance`.
+        """
+
+        instances_by_id = self.instances
+        if pid:
+            return instances_by_id[pid]
+        elif name:
+            return self.instances_by_name[name]
+        else:
+            instances = list(instances_by_id.values())
+            if definition_name:
+                definition_name = definition_name if isinstance(definition_name, list) else [definition_name]
+                instances = [inst for inst in instances if inst.padstack_definition in definition_name]
+            if net_name:
+                net_name = net_name if isinstance(net_name, list) else [net_name]
+                instances = [inst for inst in instances if inst.net_name in net_name]
+            return instances
+
     @pyedb_function_handler()
     def get_padstack_instance_by_net_name(self, net_name):
         """Get a list of padstack instances by net name.
@@ -1346,11 +1400,8 @@ class EdbPadstacks(object):
         list
             List of :class:`dotnet.edb_core.edb_data.padstacks_data.EDBPadstackInstance`.
         """
-        padstack_instances = []
-        for inst_id, inst in self.instances.items():
-            if inst.net_name == net_name:
-                padstack_instances.append(inst)
-        return padstack_instances
+        warnings.warn("Use new property :func:`get_padstack_instance` instead.", DeprecationWarning)
+        return self.get_instances(net_name=net_name)
 
     @pyedb_function_handler()
     def get_reference_pins(

pyedb/dotnet/edb_core/siwave.py

@@ -27,6 +27,7 @@ This module contains these classes: ``CircuitPort``, ``CurrentSource``, ``EdbSiw
 import os
 import time
 
+from pyedb.dotnet.edb_core.edb_data.padstacks_data import EDBPadstackInstance
 from pyedb.dotnet.edb_core.edb_data.simulation_configuration import (
     SimulationConfiguration,
     SourceType,
@@ -140,8 +141,14 @@ class EdbSiwave(object):
             Name of the source.
 
         """
-        pos_pin = source.positive_node.node_pins
-        neg_pin = source.negative_node.node_pins
+        if isinstance(source.positive_node.node_pins, EDBPadstackInstance):
+            pos_pin = source.positive_node.node_pins._edb_padstackinstance
+        else:
+            pos_pin = source.positive_node.node_pins
+        if isinstance(source.negative_node.node_pins, EDBPadstackInstance):
+            neg_pin = source.negative_node.node_pins._edb_padstackinstance
+        else:
+            neg_pin = source.negative_node.node_pins
 
         res, fromLayer_pos, toLayer_pos = pos_pin.GetLayerRange()
         res, fromLayer_neg, toLayer_neg = neg_pin.GetLayerRange()

pyedb/dotnet/edb_core/stackup.py

@@ -31,9 +31,10 @@ from collections import OrderedDict
 import json
 import logging
 import math
-import re
 import warnings
 
+import matplotlib.colors
+
 from pyedb.dotnet.edb_core.edb_data.layer_data import (
     LayerEdbClass,
     StackupLayerEdbClass,
@@ -878,6 +879,7 @@ class Stackup(object):
         else:
             return False
 
+    # TODO: This method might need some refactoring
     @pyedb_function_handler()
     def _import_layer_stackup(self, input_file=None):
         if input_file:
@@ -886,7 +888,12 @@ class Stackup(object):
             for k, v in json_dict.items():
                 if k == "materials":
                     for material in v.values():
-                        self._pedb.materials._load_materials(material)
+                        material_name = material["name"]
+                        del material["name"]
+                        if material_name not in self._pedb.materials:
+                            self._pedb.materials.add_material(material_name, **material)
+                        else:
+                            self._pedb.materials.update_material(material_name, material)
                 if k == "layers":
                     if len(list(v.values())) == len(list(self.stackup_layers.values())):
                         imported_layers_list = [l_dict["name"] for l_dict in list(v.values())]
@@ -1667,36 +1674,63 @@ class Stackup(object):
         temp_data = {name: area / outline_area * 100 for name, area in temp_data.items()}
         return temp_data
 
+    # TODO: This method might need some refactoring
     @pyedb_function_handler()
-    def _import_dict(self, json_dict):
+    def _import_dict(self, json_dict, rename=False):
         """Import stackup from a dictionary."""
-        mats = json_dict["materials"]
-        for material in mats.values():
-            self._pedb.materials._load_materials(material)
-
+        if not "materials" in json_dict:
+            self._logger.warning("Configuration file does not have material definition")
+            self._logger.warning(
+                "Please check your json or xml file, if no material are defined your project will"
+                "likely fail to simulate"
+            )
+        else:
+            mats = json_dict["materials"]
+            for material in mats.values():
+                material_name = material["name"]
+                del material["name"]
+                if material_name not in self._pedb.materials:
+                    self._pedb.materials.add_material(material_name, **material)
+                else:
+                    self._pedb.materials.update_material(material_name, material)
         temp = {i: j for i, j in json_dict["layers"].items() if j["type"] in ["signal", "dielectric"]}
+        config_file_layers = list(temp.keys())
+        layout_layers = list(self.stackup_layers.keys())
+        renamed_layers = {}
+        if rename and len(config_file_layers) == len(layout_layers):
+            for lay_ind in range(len(list(temp.keys()))):
+                if not config_file_layers[lay_ind] == layout_layers[lay_ind]:
+                    renamed_layers[layout_layers[lay_ind]] = config_file_layers[lay_ind]
         for name in list(self.stackup_layers.keys()):
+            layer = None
             if name in temp:
                 layer = temp[name]
-                default_layer = {
-                    "name": "default",
-                    "type": "signal",
-                    "material": "copper",
-                    "dielectric_fill": "fr4_epoxy",
-                    "thickness": 3.5e-05,
-                    "etch_factor": 0.0,
-                    "roughness_enabled": False,
-                    "top_hallhuray_nodule_radius": 0.0,
-                    "top_hallhuray_surface_ratio": 0.0,
-                    "bottom_hallhuray_nodule_radius": 0.0,
-                    "bottom_hallhuray_surface_ratio": 0.0,
-                    "side_hallhuray_nodule_radius": 0.0,
-                    "side_hallhuray_surface_ratio": 0.0,
-                    "upper_elevation": 0.0,
-                    "lower_elevation": 0.0,
-                    "color": [242, 140, 102],
-                }
-
+            elif name in renamed_layers:
+                layer = temp[renamed_layers[name]]
+                self.stackup_layers[name].name = renamed_layers[name]
+                name = renamed_layers[name]
+            else:  # Remove layers not in config file.
+                self.remove_layer(name)
+                self._logger.warning(f"Layer {name} were not found in configuration file, removing layer")
+            default_layer = {
+                "name": "default",
+                "type": "signal",
+                "material": "copper",
+                "dielectric_fill": "fr4_epoxy",
+                "thickness": 3.5e-05,
+                "etch_factor": 0.0,
+                "roughness_enabled": False,
+                "top_hallhuray_nodule_radius": 0.0,
+                "top_hallhuray_surface_ratio": 0.0,
+                "bottom_hallhuray_nodule_radius": 0.0,
+                "bottom_hallhuray_surface_ratio": 0.0,
+                "side_hallhuray_nodule_radius": 0.0,
+                "side_hallhuray_surface_ratio": 0.0,
+                "upper_elevation": 0.0,
+                "lower_elevation": 0.0,
+                "color": [242, 140, 102],
+            }
+            if layer:
                 if "color" in layer:
                     default_layer["color"] = layer["color"]
                 elif not layer["type"] == "signal":
@@ -1704,15 +1738,11 @@ class Stackup(object):
 
                 for k, v in layer.items():
                     default_layer[k] = v
-
                 self.stackup_layers[name]._load_layer(default_layer)
-            else:  # Remove layers not in config file.
-                self.remove_layer(name)
-
-        for layer_name, layer in temp.items():
+        for layer_name, layer in temp.items():  # looping over potential new layers to add
             if layer_name in self.stackup_layers:
                 continue  # if layer exist, skip
-
+            # adding layer
             default_layer = {
                 "name": "default",
                 "type": "signal",
@@ -1786,12 +1816,12 @@ class Stackup(object):
         return True
 
     @pyedb_function_handler()
-    def _import_json(self, file_path):
+    def _import_json(self, file_path, rename=False):
         """Import stackup from a json file."""
         if file_path:
             f = open(file_path)
             json_dict = json.load(f)  # pragma: no cover
-            return self._import_dict(json_dict)
+            return self._import_dict(json_dict, rename)
 
     @pyedb_function_handler()
     def _import_csv(self, file_path):
@@ -2035,7 +2065,7 @@ class Stackup(object):
                     material["Conductivity"] = val.conductivity
             else:
                 material["Permittivity"] = val.permittivity
-                material["DielectricLossTangent"] = val.loss_tangent
+                material["DielectricLossTangent"] = val.dielectric_loss_tangent
             materials[name] = material
 
         return layers, materials, roughness_models, non_stackup_layers
@@ -2064,11 +2094,11 @@ class Stackup(object):
         return True
 
     @pyedb_function_handler()
-    def _import_xml(self, file_path):
-        """Read external xml file and update stackup.
-        1, all existing layers must exist in xml file.
-        2, xml can have more layers than the existing stackup.
-        3, if xml has different layer order, reorder the layers according to xml definition.
+    def _import_xml(self, file_path, rename=False):
+        """Read external xml file and convert into json file.
+        You can use xml file to import layer stackup but using json file is recommended.
+        see :class:`pyedb.dotnet.edb_core.edb_data.simulation_configuration.SimulationConfiguration´ class to
+        generate files`.
 
         Parameters
         ----------
@@ -2081,59 +2111,38 @@ class Stackup(object):
             ``True`` when successful, ``False`` when failed.
         """
         tree = ET.parse(file_path)
-        material_dict = {}
         root = tree.getroot()
         stackup = root.find("Stackup")
-        for m in stackup.find("Materials").findall("Material"):
-            material = {}
-            for i in list(m):
-                material[i.tag] = list(i)[0].text
-            material_dict[m.attrib["Name"]] = material
-
-        self._add_materials_from_dictionary(material_dict)
-
-        lc_import = self._pedb.edb_api.Cell.LayerCollection()
-
-        if not lc_import.ImportFromControlFile(file_path):  # pragma: no cover
-            logger.error("Import xml failed. Please check xml content.")
-            return False
-
-        if not len(self.stackup_layers):
-            self._pedb.layout.layer_collection = lc_import
-            self.refresh_layer_collection()
-            return True
-
-        dumy_layers = OrderedDict()
-        for i in list(lc_import.Layers(self._pedb.edb_api.cell.layer_type_set.AllLayerSet)):
-            dumy_layers[i.GetName()] = i.Clone()
-
-        for name in self.layers.keys():
-            if not name in dumy_layers:
-                logger.error("{} doesn't exist in xml".format(name))
-                return False
-
-        for name, l in dumy_layers.items():
-            layer_type = re.sub(r"Layer$", "", l.GetLayerType().ToString()).lower()
-            if name in self.layers:
-                layer = self.layers[name]
-                layer.type = layer_type
-            else:
-                layer = self.add_layer(name, layer_type=layer_type, material="copper", fillMaterial="copper")
-
-            if l.IsStackupLayer():
-                layer.material = l.GetMaterial()
-                layer.thickness = l.GetThicknessValue().ToDouble()
-                layer.dielectric_fill = l.GetFillMaterial()
-                layer.etch_factor = l.GetEtchFactor().ToDouble()
-
-        lc_new = self._pedb.edb_api.Cell.LayerCollection()
-        for name, _ in dumy_layers.items():
-            layer = self.layers[name]
-            lc_new.AddLayerBottom(layer._edb_layer)
-
-        self._pedb.layout.layer_collection = lc_new
-        self.refresh_layer_collection()
-        return True
+        stackup_dict = {}
+        if stackup.find("Materials"):
+            stackup_dict["materials"] = {}
+            for m in stackup.find("Materials").findall("Material"):
+                material = {"name": m.attrib["Name"]}
+                for i in list(m):
+                    material[i.tag.lower()] = float(list(i)[0].text)
+                if material:
+                    stackup_dict["materials"][material["name"]] = material
+        stackup_section = stackup.find("Layers")
+        if stackup_section:
+            length_unit = stackup_section.attrib["LengthUnit"]
+            stackup_dict["layers"] = {}
+            for l in stackup.find("Layers").findall("Layer"):
+                layer = {"name": l.attrib["Name"]}
+                for k, v in l.attrib.items():
+                    if k == "Color":
+                        layer[k.lower()] = [int(x * 255) for x in list(matplotlib.colors.to_rgb(v))]
+                    elif k == "Thickness":
+                        layer[k.lower()] = v + length_unit
+                    elif v == "conductor":
+                        layer[k.lower()] = "signal"
+                    elif k == "FillMaterial":
+                        layer["dielectric_fill"] = v
+                    else:
+                        layer[k.lower()] = v
+                if layer:
+                    if layer["type"] == "signal" or layer["type"] == "dielectric":
+                        stackup_dict["layers"][layer["name"]] = layer
+        return self._import_dict(stackup_dict, rename=rename)
 
     @pyedb_function_handler()
     def _export_xml(self, file_path):
@@ -2187,7 +2196,7 @@ class Stackup(object):
         return True
 
     @pyedb_function_handler()
-    def load(self, file_path):
+    def load(self, file_path, rename=False):
         """Import stackup from a file. The file format can be XML, CSV, or JSON.
 
 
@@ -2195,6 +2204,11 @@ class Stackup(object):
         ----------
         file_path : str
             Path to stackup file.
+        rename : bool
+            If rename is ``False`` then layer in layout not found in the stackup file are deleted.
+            Otherwise, if the number of layer in the stackup file equals the number of stackup layer
+            in the layout, layers are renamed according the the file.
+            Note that layer order matters, and has to be writtent from top to bottom layer in the file.
 
         Returns
         -------
@@ -2213,9 +2227,9 @@ class Stackup(object):
         elif file_path.endswith(".csv"):
             return self._import_csv(file_path)
         elif file_path.endswith(".json"):
-            return self._import_json(file_path)
+            return self._import_json(file_path, rename=rename)
         elif file_path.endswith(".xml"):
-            return self._import_xml(file_path)
+            return self._import_xml(file_path, rename=rename)
         else:
             return False
 

pyedb/dotnet/edb_core/utilities/__init__.py

@@ -0,0 +1,3 @@
+from pathlib import Path
+
+workdir = Path(__file__).parent

pyedb/dotnet/edb_core/utilities/heatsink.py

@@ -0,0 +1,69 @@
+class HeatSink:
+
+    """Heatsink model description.
+
+    Parameters
+    ----------
+    pedb : :class:`pyedb.dotnet.edb.Edb`
+        Inherited object.
+    edb_object : :class:`Ansys.Ansoft.Edb.Utility.HeatSink`,
+    """
+
+    def __init__(self, pedb, edb_object=None):
+        self._pedb = pedb
+        self._fin_orientation_type = {
+            "x_oriented": self._pedb.edb_api.utility.utility.HeatSinkFinOrientation.XOriented,
+            "y_oriented": self._pedb.edb_api.utility.utility.HeatSinkFinOrientation.YOriented,
+            "other_oriented": self._pedb.edb_api.utility.utility.HeatSinkFinOrientation.OtherOriented,
+        }
+
+        if edb_object:
+            self._edb_object = edb_object
+        else:
+            self._edb_object = self._pedb.edb_api.utility.utility.HeatSink()
+
+    @property
+    def fin_base_height(self):
+        """The base elevation of the fins."""
+        return self._edb_object.FinBaseHeight.ToDouble()
+
+    @fin_base_height.setter
+    def fin_base_height(self, value):
+        self._edb_object.FinBaseHeight = self._pedb.edb_value(value)
+
+    @property
+    def fin_height(self):
+        """The fin height."""
+        return self._edb_object.FinHeight.ToDouble()
+
+    @fin_height.setter
+    def fin_height(self, value):
+        self._edb_object.FinHeight = self._pedb.edb_value(value)
+
+    @property
+    def fin_orientation(self):
+        """The fin orientation."""
+        temp = self._edb_object.FinOrientation
+        return list(self._fin_orientation_type.keys())[list(self._fin_orientation_type.values()).index(temp)]
+
+    @fin_orientation.setter
+    def fin_orientation(self, value):
+        self._edb_object.FinOrientation = self._fin_orientation_type[value]
+
+    @property
+    def fin_spacing(self):
+        """The fin spacing."""
+        return self._edb_object.FinSpacing.ToDouble()
+
+    @fin_spacing.setter
+    def fin_spacing(self, value):
+        self._edb_object.FinSpacing = self._pedb.edb_value(value)
+
+    @property
+    def fin_thickness(self):
+        """The fin thickness."""
+        return self._edb_object.FinThickness.ToDouble()
+
+    @fin_thickness.setter
+    def fin_thickness(self, value):
+        self._edb_object.FinThickness = self._pedb.edb_value(value)

pyedb/exceptions.py

@@ -0,0 +1,6 @@
+"""
+"""
+
+
+class MaterialModelException(Exception):
+    """Exception triggered when handling material model."""

pyedb/generic/filesystem.py

@@ -108,7 +108,7 @@ class Scratch:
 
         return dst_file
 
-    def copyfolder(self, src_folder, destfolder):
+    def copyfolder(self, src_folder, destfolder=None):
         """
 
         Parameters
@@ -124,8 +124,12 @@ class Scratch:
         """
         from distutils.dir_util import copy_tree
 
-        copy_tree(src_folder, destfolder)
-        return True
+        if destfolder:
+            copy_tree(src_folder, destfolder)
+        else:
+            destfolder = os.path.join(self.path, os.path.split(src_folder)[-1])
+            copy_tree(src_folder, destfolder)
+        return destfolder
 
     def __enter__(self):
         return self

pyedb/generic/general_methods.py

@@ -44,6 +44,7 @@ import tempfile
 import time
 import traceback
 
+from pyedb.exceptions import MaterialModelException
 from pyedb.generic.constants import CSS4_COLORS
 from pyedb.generic.settings import settings
 
@@ -179,6 +180,9 @@ def _function_handler_wrapper(user_function):  # pragma: no cover
             except IOError:
                 _exception(sys.exc_info(), user_function, args, kwargs, "IO Error")
                 return False
+            except MaterialModelException:
+                _exception(sys.exc_info(), user_function, args, kwargs, "Material Model")
+                return False
 
     return wrapper
 

pyedb/generic/process.py

@@ -95,7 +95,10 @@ class SiwaveSolve(object):
             command.append(self._project_path)
             command.append(exec_file)
             command.append("-formatOutput -useSubdir")
-            p = subprocess.Popen(" ".join(command))
+            if os.name == "posix":
+                p = subprocess.Popen(command)
+            else:
+                p = subprocess.Popen(" ".join(command))
             p.wait()
 
     def export_3d_cad(

pyedb/generic/settings.py

@@ -52,6 +52,7 @@ class Settings(object):
         self._force_error_on_missing_project = False
         self._enable_pandas_output = False
         self.time_tick = time.time()
+        self.retry_n_times_time_interval = 0.1
         self._global_log_file_name = "pyedb_{}.log".format(os.path.split(os.path.expanduser("~"))[-1])
         self._enable_global_log_file = True
         self._enable_local_log_file = False
@@ -240,5 +241,14 @@ class Settings(object):
         if os.path.exists(value):
             self._edb_dll_path = value
 
+    @property
+    def retry_n_times_time_interval(self):
+        """Time interval between the retries by the ``_retry_n_times`` method."""
+        return self._retry_n_times_time_interval
+
+    @retry_n_times_time_interval.setter
+    def retry_n_times_time_interval(self, value):
+        self._retry_n_times_time_interval = float(value)
+
 
 settings = Settings()