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

pyedb/__init__.py

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

pyedb/dotnet/clr_module.py

@@ -83,7 +83,7 @@ except ImportError:  # pragma: no cover
         )
         edb_initialized = False
     elif sys.version[0] == 3 and sys.version[1] < 7:
-        warnings.warn("EDB requires Linux Python 3.7 or later.")
+        warnings.warn("EDB requires Linux Python 3.8 or later.")
     _clr = None
     String = None
     Double = None

pyedb/dotnet/edb.py

@@ -848,12 +848,11 @@ class Edb(Database):
         Examples
         --------
         >>> from pyedb.dotnet.edb import Edb
-        >>> edbapp = Edb("myproject.aedb")
-        >>> edbapp.materials["FR4_epoxy"].conductivity = 1
-        >>> edbapp.materials.add_debye_material("My_Debye2", 5, 3, 0.02, 0.05, 1e5, 1e9)
-        >>> edbapp.materials.add_djordjevicsarkar_material("MyDjord2", 3.3, 0.02, 3.3)
+        >>> edbapp = Edb()
+        >>> edbapp.materials.add_material("air", permittivity=1.0)
+        >>> edbapp.materials.add_debye_material("debye_mat", 5, 3, 0.02, 0.05, 1e5, 1e9)
+        >>> edbapp.materials.add_djordjevicsarkar_material("djord_mat", 3.3, 0.02, 3.3)
         """
-
         if not self._materials and self.active_db:
             self._materials = Materials(self)
         return self._materials
@@ -3638,6 +3637,7 @@ class Edb(Database):
         >>> setup1.hfss_port_settings.max_delta_z0 = 0.5
         """
         if name in self.setups:
+            self.logger.info("setup already exists")
             return False
         setup = HfssSimulationSetup(self).create(name)
         return setup
@@ -4142,8 +4142,8 @@ class Edb(Database):
                     loss_tg_variable = "$loss_tangent_{}".format(mat_name)
                     loss_tg_variable = self._clean_string_for_variable_name(loss_tg_variable)
                     if not loss_tg_variable in self.variables:
-                        self.add_design_variable(loss_tg_variable, material.loss_tangent)
-                    material.loss_tangent = loss_tg_variable
+                        self.add_design_variable(loss_tg_variable, material.dielectric_loss_tangent)
+                    material.dielectric_loss_tangent = loss_tg_variable
                     parameters.append(loss_tg_variable)
                 else:
                     sigma_variable = "$sigma_{}".format(mat_name)

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.edb_data.obj_base import ObjBase
+from pyedb.dotnet.edb_core.obj_base import ObjBase
 from pyedb.generic.general_methods import pyedb_function_handler
 
 

pyedb/dotnet/edb_core/components.py

@@ -38,6 +38,7 @@ from pyedb.dotnet.edb_core.general import convert_py_list_to_net_list
 from pyedb.dotnet.edb_core.padstack import EdbPadstacks
 from pyedb.generic.general_methods import (
     _retry_ntimes,
+    generate_unique_name,
     get_filename_without_extension,
     pyedb_function_handler,
 )
@@ -1408,7 +1409,7 @@ class Components(object):
 
     @pyedb_function_handler()
     def create_rlc_component(
-        self, pins, component_name="", r_value=1.0, c_value=1e-9, l_value=1e-9, is_parallel=False
+        self, pins, component_name="", r_value=None, c_value=None, l_value=None, is_parallel=False
     ):  # pragma: no cover
         """Create physical Rlc component.
 
@@ -1450,13 +1451,13 @@ class Components(object):
     def create(
         self,
         pins,
-        component_name,
+        component_name=None,
         placement_layer=None,
         component_part_name=None,
         is_rlc=False,
-        r_value=0,
-        c_value=0,
-        l_value=0,
+        r_value=None,
+        c_value=None,
+        l_value=None,
         is_parallel=False,
     ):
         """Create a component from pins.
@@ -1496,6 +1497,8 @@ class Components(object):
         >>> edbapp.components.create(pins, "A1New")
 
         """
+        if not component_name:
+            component_name = generate_unique_name("Comp_")
         if component_part_name:
             compdef = self._getComponentDefinition(component_part_name, pins)
         else:
@@ -1523,21 +1526,21 @@ class Components(object):
         if is_rlc and len(pins) == 2:
             rlc = self._edb.utility.utility.Rlc()
             rlc.IsParallel = is_parallel
-            if r_value:
+            if r_value is None:
+                rlc.REnabled = False
+            else:
                 rlc.REnabled = True
                 rlc.R = self._get_edb_value(r_value)
+            if l_value is None:
+                rlc.LEnabled = False
             else:
-                rlc.REnabled = False
-            if l_value:
                 rlc.LEnabled = True
                 rlc.L = self._get_edb_value(l_value)
+            if c_value is None:
+                rlc.CEnabled = False
             else:
-                rlc.LEnabled = False
-            if c_value:
                 rlc.CEnabled = True
                 rlc.C = self._get_edb_value(c_value)
-            else:
-                rlc.CEnabled = False
             if rlc.REnabled and not rlc.CEnabled and not rlc.CEnabled:
                 new_cmp.SetComponentType(self._edb.definition.ComponentType.Resistor)
             elif rlc.CEnabled and not rlc.REnabled and not rlc.LEnabled:

pyedb/dotnet/edb_core/configuration.py

@@ -21,17 +21,13 @@
 # SOFTWARE.
 
 import json
+import os
 from pathlib import Path
 
-from pyedb.generic.general_methods import pyedb_function_handler
-
+import toml
 
-def load_json(config_file):
-    if isinstance(config_file, (str, Path)):
-        with open(config_file, "r") as f:
-            return json.load(f)
-    elif isinstance(config_file, dict):
-        return config_file
+from pyedb.dotnet.edb_core.definition.package_def import PackageDef
+from pyedb.generic.general_methods import pyedb_function_handler
 
 
 class Configuration:
@@ -46,12 +42,12 @@ class Configuration:
 
     @pyedb_function_handler
     def load(self, config_file, append=True, apply_file=False, output_file=None, open_at_the_end=True):
-        """Import configuration settings from a JSON file.
+        """Import configuration settings from a configure file.
 
         Parameters
         ----------
-        config_file : str
-            Full path to json file.
+        config_file : str, dict
+            Full path to configure file in JSON or TOML format. Dictionary is also supported.
         append : bool, optional
             Whether if the new file will append to existing properties or the properties will be cleared before import.
             Default is ``True`` to keep stored properties
@@ -67,12 +63,29 @@ class Configuration:
         dict
             Config dictionary.
         """
+        if isinstance(config_file, dict):
+            data = config_file
+        elif os.path.isfile(config_file):
+            with open(config_file, "r") as f:
+                if config_file.endswith(".json"):
+                    data = json.load(f)
+                elif config_file.endswith(".toml"):
+                    data = toml.load(f)
+        else:  # pragma: no cover
+            return False
 
-        data = load_json(config_file)
-        if not append:
+        if not append:  # pragma: no cover
             self.data = {}
         for k, v in data.items():
-            self.data[k] = v
+            if k in self.data:
+                if isinstance(v, list):
+                    self.data[k].extend(v)
+                elif isinstance(v, dict):  # pragma: no cover
+                    self.data[k].update(v)
+                else:  # pragma: no cover
+                    self.data[k] = v
+            else:
+                self.data[k] = v
         if apply_file:
             original_file = self._pedb.edbpath
             if output_file:
@@ -98,6 +111,10 @@ class Configuration:
         if "general" in self.data:
             self._load_general()
 
+        # Configure boundary settings
+        if "boundaries" in self.data:
+            self._load_boundaries()
+
         # Configure nets
         if "nets" in self.data:
             self._load_nets()
@@ -106,6 +123,10 @@ class Configuration:
         if "components" in self.data:
             self._load_components()
 
+        # Configure padstacks
+        if "padstacks" in self.data:
+            self._load_padstacks()
+
         # Configure pin groups
         if "pin_groups" in self.data:
             self._load_pin_groups()
@@ -134,6 +155,14 @@ class Configuration:
         if "spice_models" in self.data:
             self._load_spice_models()
 
+        # Configure package definitions
+        if "package_definitions" in self.data:
+            self._load_package_def()
+
+        # Configure operations
+        if "operations" in self.data:
+            self._load_operations()
+
         return True
 
     @pyedb_function_handler
@@ -253,18 +282,20 @@ class Configuration:
             pos_terminal = ""
             if "pin_group" in positive_terminal_json:
                 pin_group = self._pedb.siwave.pin_groups[positive_terminal_json["pin_group"]]
-                pos_terminal = pin_group.get_terminal(pin_group.name, True)
+                port_name = pin_group.name if "name" not in port else port["name"]
+                pos_terminal = pin_group.get_terminal(port_name, True)
+
             else:
                 ref_designator = port["reference_designator"]
                 comp_layout = self._components[ref_designator]
 
                 if "pin" in positive_terminal_json:
                     pin_name = positive_terminal_json["pin"]
-                    port_name = "{}_{}".format(ref_designator, pin_name)
+                    port_name = "{}_{}".format(ref_designator, pin_name) if "name" not in port else port["name"]
                     pos_terminal = comp_layout.pins[pin_name].get_terminal(port_name, True)
                 else:  # Net
                     net_name = positive_terminal_json["net"]
-                    port_name = "{}_{}".format(ref_designator, net_name)
+                    port_name = "{}_{}".format(ref_designator, net_name) if "name" not in port else port["name"]
                     if port_type == "circuit":
                         pg_name = "pg_{}".format(port_name)
                         _, pg = self._pedb.siwave.create_pin_group_on_net(ref_designator, net_name, pg_name)
@@ -352,6 +383,7 @@ class Configuration:
             elif src_type == "current":
                 src_obj = self._pedb.create_current_source(pos_terminal, neg_terminal)
                 src_obj.magnitude = src["magnitude"]
+            src_obj.name = name
 
     @pyedb_function_handler
     def _load_setups(self):
@@ -370,6 +402,13 @@ class Configuration:
                     self._pedb.logger.warning("Setup {} already existing. Editing it.".format(name))
                     edb_setup = self._pedb.setups[name]
                 edb_setup.set_dc_slider(setup["dc_slider_position"])
+                dc_ir_settings = setup.get("dc_ir_settings", None)
+                if dc_ir_settings:
+                    for k, v in dc_ir_settings.items():
+                        if k not in dir(edb_setup.dc_ir_settings):
+                            self._pedb.logger.error(f"Invalid keyword {k}")
+                        else:
+                            setattr(edb_setup.dc_ir_settings, k, v)
             else:
                 if setup_type.lower() == "hfss":
                     if name not in self._pedb.setups:
@@ -389,7 +428,10 @@ class Configuration:
                     else:
                         self._pedb.logger.warning("Setup {} already existing. Editing it.".format(name))
                         edb_setup = self._pedb.setups[name]
-                    edb_setup.si_slider_position = setup["si_slider_position"]
+                    if "si_slider_position" in setup:
+                        edb_setup.si_slider_position = setup["si_slider_position"]
+                    if "pi_slider_position" in setup:
+                        edb_setup.pi_slider_position = setup["pi_slider_position"]
 
                 if "freq_sweep" in setup:
                     for fsweep in setup["freq_sweep"]:
@@ -476,14 +518,23 @@ class Configuration:
             comp_def_name = sp["component_definition"]
             comp_def = self._pedb.definitions.component[comp_def_name]
             comp_def.add_n_port_model(fpath, sp_name)
+            comp_list = dict()
             if sp["apply_to_all"]:
-                for refdes, comp in comp_def.components.items():
-                    if refdes not in sp["components"]:
-                        comp.use_s_parameter_model(sp_name)
+                comp_list.update(
+                    {refdes: comp for refdes, comp in comp_def.components.items() if refdes not in sp["components"]}
+                )
             else:
-                for refdes, comp in comp_def.components.items():
-                    if refdes in sp["components"]:
-                        comp.use_s_parameter_model(sp_name)
+                comp_list.update(
+                    {refdes: comp for refdes, comp in comp_def.components.items() if refdes in sp["components"]}
+                )
+
+            for refdes, comp in comp_list.items():
+                if "reference_net_per_component" in sp:
+                    ref_net_per_comp = sp["reference_net_per_component"]
+                    ref_net = ref_net_per_comp[refdes] if refdes in ref_net_per_comp else sp["reference_net"]
+                else:
+                    ref_net = sp["reference_net"]
+                comp.use_s_parameter_model(sp_name, reference_net=ref_net)
 
     @pyedb_function_handler
     def _load_spice_models(self):
@@ -510,13 +561,21 @@ class Configuration:
     @pyedb_function_handler
     def _load_pin_groups(self):
         """Imports pin groups information from JSON."""
+        comps = self._pedb.components.components
         for pg in self.data["pin_groups"]:
             name = pg["name"]
             ref_designator = pg["reference_designator"]
             if "pins" in pg:
                 self._pedb.siwave.create_pin_group(ref_designator, pg["pins"], name)
             elif "net" in pg:
-                self._pedb.siwave.create_pin_group_on_net(ref_designator, pg["net"], name)
+                nets = pg["net"]
+                nets = nets if isinstance(nets, list) else [nets]
+                comp = comps[ref_designator]
+                pins = [p for p, obj in comp.pins.items() if obj.net_name in nets]
+                self._pedb.siwave.create_pin_group(ref_designator, pins, name)
+            else:
+                pins = [i for i in comps[ref_designator].pins.keys()]
+                self._pedb.siwave.create_pin_group(ref_designator, pins, name)
 
     @pyedb_function_handler
     def _load_nets(self):
@@ -536,3 +595,151 @@ class Configuration:
             self._s_parameter_library = general["s_parameter_library"]
         if "spice_model_library" in general:
             self._spice_model_library = general["spice_model_library"]
+
+    @pyedb_function_handler
+    def _load_boundaries(self):
+        """Imports boundary information from JSON."""
+        boundaries = self.data["boundaries"]
+
+        open_region = boundaries.get("open_region", None)
+        if open_region:
+            self._pedb.hfss.hfss_extent_info.use_open_region = open_region
+
+        open_region_type = boundaries.get("open_region_type", None)
+        if open_region_type:
+            self._pedb.hfss.hfss_extent_info.open_region_type = open_region_type
+
+        pml_visible = boundaries.get("pml_visible", None)
+        if pml_visible:
+            self._pedb.hfss.hfss_extent_info.is_pml_visible = pml_visible
+
+        pml_operation_frequency = boundaries.get("pml_operation_frequency", None)
+        if pml_operation_frequency:
+            self._pedb.hfss.hfss_extent_info.operating_freq = pml_operation_frequency
+
+        pml_radiation_factor = boundaries.get("pml_radiation_factor", None)
+        if pml_radiation_factor:
+            self._pedb.hfss.hfss_extent_info.radiation_level = pml_radiation_factor
+
+        dielectric_extents_type = boundaries.get("dielectric_extents_type", None)
+        if dielectric_extents_type:
+            self._pedb.hfss.hfss_extent_info.extent_type = dielectric_extents_type
+
+        dielectric_base_polygon = boundaries.get("dielectric_base_polygon", None)
+        if dielectric_base_polygon:
+            self._pedb.hfss.hfss_extent_info.dielectric_base_polygon = dielectric_base_polygon
+
+        horizontal_padding = boundaries.get("horizontal_padding", None)
+        if horizontal_padding:
+            self._pedb.hfss.hfss_extent_info.dielectric_extent_size = horizontal_padding
+
+        honor_primitives_on_dielectric_layers = boundaries.get("honor_primitives_on_dielectric_layers", None)
+        if honor_primitives_on_dielectric_layers:
+            self._pedb.hfss.hfss_extent_info.honor_user_dielectric = honor_primitives_on_dielectric_layers
+
+        air_box_extents_type = boundaries.get("air_box_extents_type", None)
+        if air_box_extents_type:
+            self._pedb.hfss.hfss_extent_info.extent_type = air_box_extents_type
+
+        air_box_truncate_model_ground_layers = boundaries.get("air_box_truncate_model_ground_layers", None)
+        if air_box_truncate_model_ground_layers:
+            self._pedb.hfss.hfss_extent_info.truncate_air_box_at_ground = air_box_truncate_model_ground_layers
+
+        air_box_horizontal_padding = boundaries.get("air_box_horizontal_padding", None)
+        if air_box_horizontal_padding:
+            self._pedb.hfss.hfss_extent_info.air_box_horizontal_extent = air_box_horizontal_padding
+
+        air_box_positive_vertical_padding = boundaries.get("air_box_positive_vertical_padding", None)
+        if air_box_positive_vertical_padding:
+            self._pedb.hfss.hfss_extent_info.air_box_positive_vertical_extent = air_box_positive_vertical_padding
+
+        air_box_negative_vertical_padding = boundaries.get("air_box_negative_vertical_padding", None)
+        if air_box_positive_vertical_padding:
+            self._pedb.hfss.hfss_extent_info.air_box_negative_vertical_extent = air_box_negative_vertical_padding
+
+    @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_padstacks(self):
+        """Imports padstack information from JSON."""
+        padstacks = self.data["padstacks"]
+        definitions = padstacks.get("definitions", None)
+        if definitions:
+            padstack_defs = self._pedb.padstacks.definitions
+            for value in definitions:
+                pdef = padstack_defs[value["name"]]
+                if "hole_diameter" in value:
+                    pdef.hole_diameter = value["hole_diameter"]
+                if "hole_plating_thickness" in value:
+                    pdef.hole_plating_thickness = value["hole_plating_thickness"]
+                if "hole_material" in value:
+                    pdef.material = value["hole_material"]
+                if "hole_range" in value:
+                    pdef.hole_range = value["hole_range"]
+        instances = padstacks.get("instances", None)
+        if instances:
+            padstack_instances = self._pedb.padstacks.instances_by_name
+            for value in instances:
+                inst = padstack_instances[value["name"]]
+                backdrill_top = value.get("backdrill_top", None)
+                if backdrill_top:
+                    inst.set_backdrill_top(
+                        backdrill_top["drill_to_layer"], backdrill_top["drill_diameter"], backdrill_top["stub_length"]
+                    )
+                backdrill_bottom = value.get("backdrill_bottom", None)
+                if backdrill_top:
+                    inst.set_backdrill_bottom(
+                        backdrill_bottom["drill_to_layer"],
+                        backdrill_bottom["drill_diameter"],
+                        backdrill_bottom["stub_length"],
+                    )
+
+    @pyedb_function_handler
+    def _load_package_def(self):
+        """Imports package definition information from JSON."""
+        comps = self._pedb.components.components
+        for pkgd in self.data["package_definitions"]:
+            name = pkgd["name"]
+            if name in self._pedb.definitions.package:
+                self._pedb.definitions.package[name].delete()
+            extent_bounding_box = pkgd.get("extent_bounding_box", None)
+            if extent_bounding_box:
+                package_def = PackageDef(self._pedb, name=name, extent_bounding_box=extent_bounding_box)
+            else:
+                package_def = PackageDef(self._pedb, name=name, component_part_name=pkgd["component_definition"])
+            package_def.maximum_power = pkgd["maximum_power"]
+            package_def.therm_cond = pkgd["therm_cond"]
+            package_def.theta_jb = pkgd["theta_jb"]
+            package_def.theta_jc = pkgd["theta_jc"]
+            package_def.height = pkgd["height"]
+
+            heatsink = pkgd.get("heatsink", None)
+            if heatsink:
+                package_def.set_heatsink(
+                    heatsink["fin_base_height"],
+                    heatsink["fin_height"],
+                    heatsink["fin_orientation"],
+                    heatsink["fin_spacing"],
+                    heatsink["fin_thickness"],
+                )
+
+            comp_def_name = pkgd["component_definition"]
+            comp_def = self._pedb.definitions.component[comp_def_name]
+
+            comp_list = dict()
+            if pkgd["apply_to_all"]:
+                comp_list.update(
+                    {refdes: comp for refdes, comp in comp_def.components.items() if refdes not in pkgd["components"]}
+                )
+            else:
+                comp_list.update(
+                    {refdes: comp for refdes, comp in comp_def.components.items() if refdes in pkgd["components"]}
+                )
+            for _, i in comp_list.items():
+                i.package_def = name

pyedb/dotnet/edb_core/definition/component_def.py

@@ -23,7 +23,7 @@
 import os
 
 from pyedb.dotnet.edb_core.definition.component_model import NPortComponentModel
-from pyedb.dotnet.edb_core.edb_data.obj_base import ObjBase
+from pyedb.dotnet.edb_core.obj_base import ObjBase
 from pyedb.generic.general_methods import pyedb_function_handler
 
 
@@ -152,6 +152,15 @@ class EDBComponentDef(ObjBase):
             comp.assign_spice_model(file_path, model_name)
         return True
 
+    @property
+    def reference_file(self):
+        ref_files = []
+        for comp_model in self._comp_model:
+            model_type = str(comp_model.GetComponentModelType())
+            if model_type == "NPortComponentModel" or model_type == "DynamicLinkComponentModel":
+                ref_files.append(comp_model.GetReferenceFile())
+        return ref_files
+
     @property
     def component_models(self):
         temp = {}

pyedb/dotnet/edb_core/definition/component_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.edb_data.obj_base import ObjBase
+from pyedb.dotnet.edb_core.obj_base import ObjBase
 from pyedb.generic.general_methods import pyedb_function_handler
 
 

pyedb/dotnet/edb_core/definition/definition_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.edb_data.obj_base import ObjBase
+from pyedb.dotnet.edb_core.obj_base import ObjBase
 
 
 class DefinitionObj(ObjBase):

pyedb/dotnet/edb_core/definition/definitions.py

@@ -40,17 +40,23 @@ class Definitions:
         return {l.GetName(): PackageDef(self._pedb, l) for l in list(self._pedb.active_db.PackageDefs)}
 
     @pyedb_function_handler
-    def add_package_def(self, name):
+    def add_package_def(self, name, component_part_name=None, boundary_points=None):
         """Add a package definition.
 
         Parameters
         ----------
         name: str
             Name of the package definition.
+        component_part_name : str, optional
+            Part name of the component.
+        boundary_points : list, optional
+            Boundary points which define the shape of the package.
 
         Returns
         -------
 
         """
-        package_def = PackageDef(self._pedb, name=name)
+        package_def = PackageDef(
+            self._pedb, name=name, component_part_name=component_part_name, extent_bounding_box=boundary_points
+        )
         return package_def