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

pyedb/__init__.py

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

pyedb/configuration/cfg_boundaries.py

@@ -27,25 +27,25 @@ class CfgBoundaries:
     def __init__(self, pdata, boundaries_dict):
         self._pedb = pdata.pedb
         self._boundaries_dict = boundaries_dict
-        self.open_region = self._boundaries_dict.get("open_region", True)
+        self.open_region = self._boundaries_dict.get("open_region", None)
         self._map_open_region_type()
-        self.pml_visible = self._boundaries_dict.get("pml_visible", False)
-        self.pml_operation_frequency = self._boundaries_dict.get("pml_operation_frequency", "5GHz")
-        self.pml_radiation_factor = self._boundaries_dict.get("pml_radiation_factor", 10)
+        self.pml_visible = self._boundaries_dict.get("pml_visible", None)
+        self.pml_operation_frequency = self._boundaries_dict.get("pml_operation_frequency", None)
+        self.pml_radiation_factor = self._boundaries_dict.get("pml_radiation_factor", None)
         self._map_dielectric_extend_type()
-        self.dielectric_base_polygon = self._boundaries_dict.get("dielectric_base_polygon", "")
-        self.horizontal_padding = self._boundaries_dict.get("horizontal_padding", 0.0)
+        self.dielectric_base_polygon = self._boundaries_dict.get("dielectric_base_polygon", None)
+        self.horizontal_padding = self._boundaries_dict.get("horizontal_padding", None)
         self.honor_primitives_on_dielectric_layers = self._boundaries_dict.get(
             "honor_primitives_on_dielectric_layers", False
         )
         self._map_air_box_extend_type()
-        self.air_box_base_polygon = self._boundaries_dict.get("air_box_base_polygon", "")
+        self.air_box_base_polygon = self._boundaries_dict.get("air_box_base_polygon", None)
         self.air_box_truncate_model_ground_layers = self._boundaries_dict.get(
-            "air_box_truncate_model_ground_layers", False
+            "air_box_truncate_model_ground_layers", None
         )
-        self.air_box_horizontal_padding = self._boundaries_dict.get("air_box_horizontal_padding", 0.15)
-        self.air_box_positive_vertical_padding = self._boundaries_dict.get("air_box_positive_vertical_padding", 1)
-        self.air_box_negative_vertical_padding = self._boundaries_dict.get("air_box_negative_vertical_padding", 1)
+        self.air_box_horizontal_padding = self._boundaries_dict.get("air_box_horizontal_padding", None)
+        self.air_box_positive_vertical_padding = self._boundaries_dict.get("air_box_positive_vertical_padding", None)
+        self.air_box_negative_vertical_padding = self._boundaries_dict.get("air_box_negative_vertical_padding", None)
 
     def _map_air_box_extend_type(self):
         air_box_type = self._boundaries_dict.get("air_box_extents_type", None)
@@ -94,22 +94,32 @@ class CfgBoundaries:
 
     def apply(self):
         """Imports boundary information from JSON."""
-        self._pedb.hfss.hfss_extent_info.use_open_region = self.open_region
+        if self.open_region is not None:
+            self._pedb.hfss.hfss_extent_info.use_open_region = self.open_region
         self._pedb.hfss.hfss_extent_info.open_region_type = self.open_region_type.name.lower()
-        self._pedb.hfss.hfss_extent_info.is_pml_visible = self.pml_visible
-        self._pedb.hfss.hfss_extent_info.operating_freq = self.pml_operation_frequency
-        self._pedb.hfss.hfss_extent_info.radiation_level = self.pml_radiation_factor
+        if self.pml_visible is not None:
+            self._pedb.hfss.hfss_extent_info.is_pml_visible = self.pml_visible
+        if self.pml_operation_frequency:
+            self._pedb.hfss.hfss_extent_info.operating_freq = self.pml_operation_frequency
+        if self.pml_radiation_factor:
+            self._pedb.hfss.hfss_extent_info.radiation_level = self.pml_radiation_factor
         self._pedb.hfss.hfss_extent_info.extent_type = self.dielectric_extents_type.name.lower()
         if self.dielectric_base_polygon:
             self._pedb.hfss.hfss_extent_info.dielectric_base_polygon = self.dielectric_base_polygon
-        self._pedb.hfss.hfss_extent_info.dielectric_extent_size = float(self.horizontal_padding)
-        self._pedb.hfss.hfss_extent_info.honor_user_dielectric = self.honor_primitives_on_dielectric_layers
+        if self.horizontal_padding:
+            self._pedb.hfss.hfss_extent_info.dielectric_extent_size = float(self.horizontal_padding)
+        if self.honor_primitives_on_dielectric_layers is not None:
+            self._pedb.hfss.hfss_extent_info.honor_user_dielectric = self.honor_primitives_on_dielectric_layers
         self._pedb.hfss.hfss_extent_info.extent_type = self.air_box_extents_type.name.lower()
-        self._pedb.hfss.hfss_extent_info.truncate_air_box_at_ground = self.air_box_truncate_model_ground_layers
-        self._pedb.hfss.hfss_extent_info.air_box_horizontal_extent = float(self.air_box_horizontal_padding)
-        self._pedb.hfss.hfss_extent_info.air_box_positive_vertical_extent = float(
-            self.air_box_positive_vertical_padding
-        )
-        self._pedb.hfss.hfss_extent_info.air_box_negative_vertical_extent = float(
-            self.air_box_negative_vertical_padding
-        )
+        if self.air_box_truncate_model_ground_layers is not None:
+            self._pedb.hfss.hfss_extent_info.truncate_air_box_at_ground = self.air_box_truncate_model_ground_layers
+        if self.air_box_horizontal_padding:
+            self._pedb.hfss.hfss_extent_info.air_box_horizontal_extent = float(self.air_box_horizontal_padding)
+        if self.air_box_positive_vertical_padding:
+            self._pedb.hfss.hfss_extent_info.air_box_positive_vertical_extent = float(
+                self.air_box_positive_vertical_padding
+            )
+        if self.air_box_negative_vertical_padding:
+            self._pedb.hfss.hfss_extent_info.air_box_negative_vertical_extent = float(
+                self.air_box_negative_vertical_padding
+            )

pyedb/configuration/cfg_data.py

@@ -39,30 +39,42 @@ class CfgData(object):
         self.pedb = pedb
         self.edb_comps = self.pedb.components.components
         self.general = CfgGeneral(self, kwargs.get("general", None))
+
         self.boundaries = {}
         if kwargs.get("boundaries", None):
             self.boundaries = CfgBoundaries(self, kwargs.get("boundaries", None))
-        self.nets = CfgNets(self)
+
+        self.nets = None
         if kwargs.get("nets"):
             self.nets = CfgNets(
                 self, kwargs.get("nets", {}).get("signal_nets", []), kwargs.get("nets", {}).get("power_ground_nets", [])
             )
+
         self.components = [CfgComponent(self, **component) for component in kwargs.get("components", [])]
+
         self.padstacks = CfgPadstacks(self, kwargs.get("padstacks", None))
+
         self.pin_groups = [CfgPinGroup(self, pin_group) for pin_group in kwargs.get("pin_groups", [])]
+
         self.ports = [CfgPort(self, **port) for port in kwargs.get("ports", [])]
+
         self.sources = [CfgSources(self, **source) for source in kwargs.get("sources", [])]
-        self.setups = [CfgSetup(self)]
+
+        self.setups = []
         if kwargs.get("setups", None):
             self.setups = [CfgSetup(self, setup) for setup in kwargs.get("setups", [])]
+
         self.stackup = None
+
         self.s_parameters = [
             CfgSParameterModel(self, self.general.s_parameter_library, sparam_model)
             for sparam_model in kwargs.get("s_parameters", [])
         ]
+
         self.spice_models = [
             CfgSpiceModel(self, self.general.spice_model_library, spice_model)
             for spice_model in kwargs.get("spice_models", [])
         ]
+
         self.package_definition = None
         self.operations = None

pyedb/configuration/cfg_padstacks.py

@@ -54,20 +54,24 @@ class Definition:
     def __init__(self, pdata, definition_dict):
         self._pedb = pdata.pedb
         self._definition_dict = definition_dict
-        self.name = self._definition_dict.get("name", "")
-        self.hole_diameter = self._definition_dict.get("hole_diameter", "")
-        self.hole_plating_thickness = self._definition_dict.get("hole_plating_thickness", "")
-        self.hole_material = self._definition_dict.get("hole_material", "")
-        self.hole_range = self._definition_dict.get("hole_range", "")
+        self.name = self._definition_dict.get("name", None)
+        self.hole_diameter = self._definition_dict.get("hole_diameter", None)
+        self.hole_plating_thickness = self._definition_dict.get("hole_plating_thickness", None)
+        self.hole_material = self._definition_dict.get("hole_material", None)
+        self.hole_range = self._definition_dict.get("hole_range", None)
 
     def apply(self):
         """Apply padstack definition on layout."""
         padstack_defs = self._pedb.padstacks.definitions
         pdef = padstack_defs[self.name]
-        pdef.hole_diameter = self.hole_diameter
-        pdef.hole_plating_thickness = self.hole_plating_thickness
-        pdef.material = self.hole_material
-        pdef.hole_range = self.hole_range
+        if self.hole_diameter:
+            pdef.hole_diameter = self.hole_diameter
+        if self.hole_plating_thickness:
+            pdef.hole_plating_thickness = self.hole_plating_thickness
+        if self.hole_material:
+            pdef.material = self.hole_material
+        if self.hole_range:
+            pdef.hole_range = self.hole_range
 
 
 class Instance:

pyedb/configuration/cfg_pin_groups.py

@@ -36,7 +36,7 @@ class CfgPinGroup:
         """Apply pin group on layout."""
         if self.pins:
             if not self._pedb.siwave.create_pin_group(self.reference_designator, list(self.pins), self.name):
-                self._pedb.loogger.error(f"Failed to create pin group on pins {self.pins}")
+                self._pedb.logger.error(f"Failed to create pin group on pins {self.pins}")
                 return False
             self._pedb.logger.info(f"Pin group {self.name} created.")
             return True

pyedb/configuration/cfg_ports_sources.py

@@ -41,8 +41,8 @@ class CfgCircuitElement:
         self.neg_term_info = kwargs.get("negative_terminal", None)
 
     @pyedb_function_handler
-    def _create(self):
-        """Create step 1."""
+    def _create_terminals(self):
+        """Create step 1. Collect positive and negative terminals."""
         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]
@@ -71,16 +71,26 @@ class CfgCircuitElement:
         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]}
+            if neg_type == "nearest_pin":
+                ref_net = neg_value.get("reference_net", "GND")
+                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]
+                self.neg_terminal = {
+                    i: j.create_terminal(i + "_ref") if not j.terminal else j.terminal for i, j in temp.items()
+                }
             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
-            ]
+                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):
@@ -125,11 +135,14 @@ class CfgPort(CfgCircuitElement):
     @pyedb_function_handler
     def create(self):
         """Create port."""
-        self._create()
+        self._create_terminals()
         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)
+        for name, j in self.pos_terminals.items():
+            if isinstance(self.neg_terminal, dict):
+                elem = self.pedb.create_port(j, self.neg_terminal[name], is_circuit_port)
+            else:
+                elem = self.pedb.create_port(j, self.neg_terminal, is_circuit_port)
             if not self.distributed:
                 elem.name = self.name
             circuit_elements.append(elem)
@@ -148,12 +161,15 @@ class CfgSources(CfgCircuitElement):
     @pyedb_function_handler
     def create(self):
         """Create sources."""
-        self._create()
+        self._create_terminals()
         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)
+        for name, j in self.pos_terminals.items():
+            if isinstance(self.neg_terminal, dict):
+                elem = method(j, self.neg_terminal[name])
+            else:
+                elem = method(j, self.neg_terminal)
             if not self.distributed:
                 elem.name = self.name
                 elem.magnitude = self.magnitude

pyedb/configuration/configuration.py

@@ -27,7 +27,6 @@ import toml
 
 from pyedb.configuration.cfg_data import CfgData
 from pyedb.dotnet.edb_core.definition.package_def import PackageDef
-from pyedb.dotnet.edb_core.stackup import LayerCollection
 from pyedb.generic.general_methods import pyedb_function_handler
 
 
@@ -182,56 +181,44 @@ class Configuration:
         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):
+            if not len(input_signal_layers) == len(self._pedb.stackup.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_new = LayerCollection(self._pedb)
-            lc_new.auto_refresh = False
-            signal_layer_ids = {}
-            top_layer_clone = None
-
-            # add all signal 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":
-                    clone = layer_clones.pop(0)
-                    clone.update(**l)
-                    lc_new.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_new.add_document_layer(name=l.name, layer_clone=l)
-                first_doc_layer_name = doc_layer.name
+                    layer_id = lc_signal_layers[signal_idx]
+                    layer_name = id_name[layer_id]
+                    self._pedb.stackup.layers[layer_name].update(**l)
+                    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 = lc_new.layers[l["name"]]
+                prev_layer_clone = self._pedb.stackup.layers[l["name"]]
             else:
-                prev_layer_clone = lc_new.add_layer_top(**l)
+                prev_layer_clone = self._pedb.stackup.add_layer_top(**l)
             for idx, l in enumerate(layers):
                 if l["type"] == "dielectric":
-                    prev_layer_clone = lc_new.add_layer_below(base_layer_name=prev_layer_clone.name, **l)
-                else:
-                    prev_layer_clone = lc_new.layers[l["name"]]
-
-            lc._edb_object = lc_new._edb_object
-            lc_new.auto_refresh = True
-            lc.update_layout()
+                    prev_layer_clone = self._pedb.stackup.add_layer_below(base_layer_name=prev_layer_clone.name, **l)
+                elif l["type"] == "signal":
+                    prev_layer_clone = self._pedb.stackup.layers[l["name"]]
 
     @pyedb_function_handler
     def _load_operations(self):

pyedb/dotnet/edb.py

@@ -846,9 +846,7 @@ class Edb(Database):
         >>> edbapp.stackup.layers["TOP"].thickness == 4e-05
         >>> 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.layout.layer_collection)
-        return self._stackup2
+        return Stackup(self, self.layout.layer_collection)
 
     @property
     def materials(self):
@@ -3702,12 +3700,10 @@ class Edb(Database):
             self.logger.error("Setup name already used in the layout")
             return False
         version = self.edbversion.split(".")
-        if int(version[0]) == 2024 and int(version[-1]) >= 2 or int(version[0]) > 2024:
-            setup = HFSSPISimulationSetup(self).create(name)
-            return setup
-        else:
+        if float(self.edbversion) < 2024.2:
             self.logger.error("HFSSPI simulation only supported with Ansys release 2024R2 and higher")
             return False
+        return HFSSPISimulationSetup(self).create(name)
 
     @pyedb_function_handler()
     def create_siwave_syz_setup(self, name=None):

pyedb/dotnet/edb_core/edb_data/hfss_simulation_setup_data.py

@@ -977,19 +977,18 @@ class ViaSettings(object):
         -------
         bool
         """
-        if self._parent._pedb.version[0] >= 10:
-            return self._via_settings.ViaMeshPlating
-        else:
+        if float(self._parent._pedb.edbversion) < 2024.1:
             self._parent._pedb.logger.error("Property only supported on Ansys release 2024R1 and later")
             return False
+        return self._via_settings.ViaMeshPlating
 
     @via_mesh_plating.setter
     def via_mesh_plating(self, value):
-        if self._parent._pedb.version[0] >= 10:
+        if float(self._parent._pedb.edbversion) < 2024.1:
+            self._parent._pedb.logger.error("Property only supported on Ansys release 2024R1 and later")
+        else:
             self._via_settings.ViaMeshPlating = value
             self._parent._update_setup()
-        else:
-            self._parent._pedb.logger.error("Property only supported on Ansys release 2024R1 and later")
 
     @property
     def via_material(self):

pyedb/dotnet/edb_core/edb_data/layer_data.py

@@ -257,8 +257,8 @@ class StackupLayerEdbClass(LayerEdbClass):
         self._lower_elevation = 0.0
 
     def _create(self, layer_type):
-        layer_type = self._layer_name_mapping[layer_type]
-        layer_type = self._layer_type_mapping[layer_type]
+        layer_type_edb_name = self._layer_name_mapping[layer_type]
+        layer_type = self._layer_type_mapping[layer_type_edb_name]
         self._edb_object = self._pedb.edb_api.cell._cell.StackupLayer(
             self._name,
             layer_type,

pyedb/dotnet/edb_core/edb_data/padstacks_data.py

@@ -1183,7 +1183,7 @@ class EDBPadstackInstance(EDBPrimitivesMain):
         -------
         :class:`pyedb.dotnet.edb_core.edb_data.terminals`
         """
-
+        warnings.warn("Use new property :func:`terminal` instead.", DeprecationWarning)
         if create_new_terminal:
             term = self._create_terminal(name)
         else:
@@ -1195,6 +1195,14 @@ class EDBPadstackInstance(EDBPrimitivesMain):
         if not term.is_null:
             return term
 
+    @property
+    def terminal(self):
+        """Terminal."""
+        from pyedb.dotnet.edb_core.edb_data.terminals import PadstackInstanceTerminal
+
+        term = PadstackInstanceTerminal(self._pedb, self._edb_object.GetPadstackInstanceTerminal())
+        return term if not term.is_null else None
+
     @pyedb_function_handler()
     def _create_terminal(self, name=None):
         """Create a padstack instance terminal"""

pyedb/dotnet/edb_core/siwave.py

@@ -1259,6 +1259,7 @@ class EdbSiwave(object):
         )
 
         if edb_pingroup.IsNull():  # pragma: no cover
+            self._logger.error(f"Failed to create pin group {group_name}.")
             return False
         else:
             names = [i for i in pins if i.GetNet().GetName()]

pyedb/dotnet/edb_core/stackup.py

@@ -69,8 +69,6 @@ logger = logging.getLogger(__name__)
 
 
 class LayerCollection(object):
-    auto_refresh = True
-
     def __init__(self, pedb, edb_object=None):
         self._pedb = pedb
 
@@ -91,17 +89,21 @@ class LayerCollection(object):
             "multizone": self._pedb.edb_api.cell._cell.LayerCollectionMode.MultiZone,
         }
 
-    def update_layout(self, stackup=None):
+    def update_layout(self):
         """Set layer collection into edb.
 
         Parameters
         ----------
         stackup
         """
-        if stackup:
-            self._edb_object = stackup._edb_object
         self._pedb.layout.layer_collection = self._edb_object
 
+    @pyedb_function_handler()
+    def refresh_layer_collection(self):
+        """Refresh layer collection from Edb. This method is run on demand after all edit operations on stackup."""
+        self._edb_object = self._pedb.edb_api.cell._cell.LayerCollection(self._pedb.layout.layer_collection)
+        self._lc = self._edb_object
+
     @pyedb_function_handler
     def _add_layer(self, add_method, base_layer_name="", **kwargs):
         """Add a layer to edb.
@@ -115,7 +117,13 @@ class LayerCollection(object):
         if layer_clone:
             obj = layer_clone
         else:
-            obj = StackupLayerEdbClass(self._pedb, edb_object=None, **kwargs)
+            layer_type = kwargs.get("layer_type", None)
+            if not layer_type:
+                layer_type = kwargs["type"]
+            if layer_type in ["signal", "dielectric"]:
+                obj = StackupLayerEdbClass(self._pedb, edb_object=None, **kwargs)
+            else:
+                obj = LayerEdbClass(self._pedb, edb_object=None, **kwargs)
         method_top_bottom = None
         method_above_below = None
         if add_method == "add_layer_top":
@@ -134,8 +142,7 @@ class LayerCollection(object):
             obj = obj if method_top_bottom(obj._edb_object) else False
         elif method_above_below:
             obj = obj if method_above_below(obj._edb_object, base_layer_name) else False
-        if self.auto_refresh:
-            self.update_layout()
+        self.update_layout()
         return obj
 
     @pyedb_function_handler
@@ -268,8 +275,7 @@ class LayerCollection(object):
                 lc.AddLayerBottom(i._edb_object)
 
         self._edb_object = lc
-        if self.auto_refresh:
-            self.update_layout()
+        self.update_layout()
 
         if not obj:
             logger.info("Layer clone was not found in stackup or non stackup layers.")
@@ -278,33 +284,32 @@ class LayerCollection(object):
     @property
     def stackup_layers(self):
         """Retrieve the dictionary of signal and dielectric layers."""
-        temp = list(self._edb_object.Layers((self._pedb.edb_api.cell.layer_type_set.StackupLayerSet)))
-        layers = OrderedDict()
-        for i in temp:
-            name = i.GetName()
-            layers[name] = StackupLayerEdbClass(self._pedb, i.Clone(), name=name)
-        return layers
+        warnings.warn("Use new property :func:`layers` instead.", DeprecationWarning)
+        return self.layers
 
     @property
     def non_stackup_layers(self):
         """Retrieve the dictionary of signal layers."""
-        temp = list(self._edb_object.Layers(self._layer_type_set_mapping["non_stackup_layer_set"]))
-        layers = OrderedDict()
-        for i in temp:
-            name = i.GetName()
-            layers[name] = LayerEdbClass(self._pedb, i, name=name)
-        return layers
+        return {name: obj for name, obj in self.all_layers.items() if not obj.is_stackup_layer}
 
     @property
-    def layers_by_id(self):
-        """Retrieve the list of layers with their ids."""
-        layer_list = list(self._layer_collection.Layers(self._pedb.edb_api.cell.layer_type_set.AllLayerSet))
-        temp = []
+    def all_layers(self):
+        self.refresh_layer_collection()
+        layer_list = list(self._edb_object.Layers(self._pedb.edb_api.cell.layer_type_set.AllLayerSet))
+        temp = dict()
         for i in layer_list:
-            obj = StackupLayerEdbClass(self._pedb, i.Clone(), name=i.GetName)
-            temp.append([obj.id, obj.name])
+            if i.IsStackupLayer():
+                obj = StackupLayerEdbClass(self._pedb, i.Clone(), name=i.GetName())
+            else:
+                obj = LayerEdbClass(self._pedb, i.Clone(), name=i.GetName())
+            temp[obj.name] = obj
         return temp
 
+    @property
+    def layers_by_id(self):
+        """Retrieve the list of layers with their ids."""
+        return [[obj.id, name] for name, obj in self.all_layers.items()]
+
     @property
     def layers(self):
         """Retrieve the dictionary of layers.
@@ -313,22 +318,14 @@ class LayerCollection(object):
         -------
         Dict[str, :class:`pyedb.dotnet.edb_core.edb_data.layer_data.LayerEdbClass`]
         """
-        _lays = OrderedDict()
-        layer_list = list(self._edb_object.Layers(self._pedb.edb_api.cell.layer_type_set.AllLayerSet))
-        for l in layer_list:
-            name = l.GetName()
-            if not l.IsStackupLayer():
-                _lays[name] = LayerEdbClass(self._pedb, l, name=name)
-            else:
-                _lays[name] = StackupLayerEdbClass(self._pedb, l, name=name)
-        return _lays
+        return {name: obj for name, obj in self.all_layers.items() if obj.is_stackup_layer}
 
 
 class Stackup(LayerCollection):
     """Manages EDB methods for stackup accessible from `Edb.stackup` property."""
 
     def __getitem__(self, item):
-        return self.layers[item]
+        return self.all_layers[item]
 
     def __init__(self, pedb, edb_object=None):
         super().__init__(pedb, edb_object)
@@ -576,12 +573,6 @@ class Stackup(LayerCollection):
             )
         return True
 
-    @pyedb_function_handler()
-    def refresh_layer_collection(self):
-        """Refresh layer collection from Edb. This method is run on demand after all edit operations on stackup."""
-        self._lc = self._pedb.edb_api.cell._cell.LayerCollection(self._pedb.layout.layer_collection)
-        self._edb_object = self._lc
-
     @property
     def _layer_collection(self):
         """Copy of EDB layer collection.
@@ -591,8 +582,7 @@ class Stackup(LayerCollection):
         :class:`Ansys.Ansoft.Edb.Cell.LayerCollection`
             Collection of layers.
         """
-        if not self._lc:
-            self.refresh_layer_collection()
+        self.refresh_layer_collection()
         return self._lc
 
     @property
@@ -620,7 +610,7 @@ class Stackup(LayerCollection):
             self._layer_collection.SetMode(mode.Overlapping)
         elif value == 2 or value == mode.MultiZone or value == "MultiZone":
             self._layer_collection.SetMode(mode.MultiZone)
-        self._pedb.layout.layer_collection = self._layer_collection
+        self.update_layout()
 
     @property
     def stackup_mode(self):
@@ -744,9 +734,8 @@ class Stackup(LayerCollection):
             _lc.AddStackupLayerAtElevation(layer_clone)
         elif operation == "non_stackup":
             _lc.AddLayerBottom(layer_clone)
-        if self.auto_refresh:
-            self._pedb.layout.layer_collection = _lc
-            self.refresh_layer_collection()
+        self._pedb.layout.layer_collection = _lc
+        self.refresh_layer_collection()
         return True
 
     @pyedb_function_handler()
@@ -814,17 +803,7 @@ class Stackup(LayerCollection):
         bool
             "True" if successful, ``False`` if failed.
         """
-        outlineLayer = self._pedb.edb_api.cell.layer.FindByName(self._pedb.layout.layer_collection, outline_name)
-        if outlineLayer.IsNull():
-            return self.add_layer(
-                outline_name,
-                layer_type="outline",
-                material="",
-                fillMaterial="",
-                thickness="",
-            )
-        else:
-            return False
+        return self.add_document_layer(name="Outline", layer_type="outline")
 
     # TODO: Update optional argument material into material_name and fillMaterial into fill_material_name
     @pyedb_function_handler()

pyedb/dotnet/edb_core/utilities/simulation_setup.py

@@ -36,6 +36,7 @@ class BaseSimulationSetup(object):
         EDB object.
     """
 
+    @pyedb_function_handler
     def __init__(self, pedb, edb_setup=None):
         self._pedb = pedb
         self._edb_object = edb_setup
@@ -59,7 +60,7 @@ class BaseSimulationSetup(object):
         }
 
         version = self._pedb.edbversion.split(".")
-        if int(version[0]) == 2024 and int(version[1]) == 2 or int(version[0]) > 2024:
+        if float(self._pedb.edbversion) >= 2024.2:
             self._setup_type_mapping.update(
                 {
                     "kRaptorX": self._pedb.simsetupdata.RaptorX.RaptorXSimulationSettings,

{pyedb-0.11.2.dist-info → pyedb-0.12.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyedb
-Version: 0.11.2
+Version: 0.12.1
 Summary: Higher-Level Pythonic Ansys Electronics Data Base
 Author-email: "ANSYS, Inc." <pyansys.core@ansys.com>
 Maintainer-email: PyEDB developers <simon.vandenbrouck@ansys.com>

{pyedb-0.11.2.dist-info → pyedb-0.12.1.dist-info}/RECORD

@@ -1,23 +1,23 @@
-pyedb/__init__.py,sha256=C795I8bcWORZf5IJiI-M1ZRxjImvymTFp4TDMevi0j0,1521
+pyedb/__init__.py,sha256=6XNbzc6ACi5_YyN4AHoYcryfduYa2LhbWMGddPbk0aQ,1521
 pyedb/edb_logger.py,sha256=yNkXnoL2me7ubLT6O6r6ElVnkZ1g8fmfFYC_2XJZ1Sw,14950
 pyedb/exceptions.py,sha256=n94xluzUks6BA24vd_L6HkrvoP_H_l6__hQmqzdCyPo,111
 pyedb/siwave.py,sha256=c2stPkGPdM9c0wJ19SJq_uiYTdW3sp-uO8MVA_iDw30,12548
 pyedb/configuration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyedb/configuration/cfg_boundaries.py,sha256=ABjSlQCRMJNw1YX2B4aADNlLrrFbdyv7UWewiXVdxTk,6105
+pyedb/configuration/cfg_boundaries.py,sha256=iThJw52omnGikp20uNVgW4w0VcrzF68dXUaMb2MfOt4,6646
 pyedb/configuration/cfg_components.py,sha256=cvQfMjh6HBTVzVuDI7A8zkEhtgraG25dJqHRH-FbkTA,8789
-pyedb/configuration/cfg_data.py,sha256=ZThr2rpCj4axwrBr-aQWtiTztEhRAZb1pX-S3_92aJQ,3483
+pyedb/configuration/cfg_data.py,sha256=uSgyJaKMzw8f_-uWc5bp0MnXnoWRZHxSipIkA_4pSQY,3472
 pyedb/configuration/cfg_general.py,sha256=dB5Tpird4uiyrseOe8-QlWKsat15TjMLar5I8VZME3c,1625
 pyedb/configuration/cfg_nets.py,sha256=mJvN_ON4Qw5psNV3agXCQAhVJbRnBpRZu1Ti3b7QnMw,1879
-pyedb/configuration/cfg_padstacks.py,sha256=dcZku_OuZ2XaL5Vs8BEJvdcdi1N8F0EMAYNwBSdkbt0,5412
-pyedb/configuration/cfg_pin_groups.py,sha256=BAv-u1e8aPXSTBwUBzDkzRiXB2mfCqb60I5tTrwgI7Y,2877
-pyedb/configuration/cfg_ports_sources.py,sha256=iY5GH_ff50bt3muz2w_k9_3VTj_Yigk8Iqfh37a7vRU,6816
+pyedb/configuration/cfg_padstacks.py,sha256=5ta0xkdSaf4qk5lXjM-U4GB2vNS31nhEGsZwwRlhPUI,5568
+pyedb/configuration/cfg_pin_groups.py,sha256=bW_RqTYNFE7i-C74pWY2pUIWoSKMQY-TWW17FIftfQk,2876
+pyedb/configuration/cfg_ports_sources.py,sha256=kicbrgw1YLB2m7xJhrjo9LcfcbwTncGguuzEjZ2pUcQ,7787
 pyedb/configuration/cfg_s_parameter_models.py,sha256=HPo4sgF5tVefUwgzlP8pDBVSZ1x_pY2EiOtA0-QXjc8,2854
 pyedb/configuration/cfg_setup.py,sha256=zhq285s5P4s90Dm5s550ldwyIVO8aXiPjAwy87ipRXU,8791
 pyedb/configuration/cfg_spice_models.py,sha256=5gr28-4u4uj4qY8vgYFAI_PgzOQp-wPgTMMc_WcAN_w,2434
-pyedb/configuration/configuration.py,sha256=ykDlI3v8w8x-qWuV8PrwIAHVe9jmBwCb8OeJLfBF4lk,10965
+pyedb/configuration/configuration.py,sha256=hPyUzdOJlMGPaI-Ie3Q1jJpmzpzrAy6XgWjSv8LQ8Q0,10628
 pyedb/dotnet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyedb/dotnet/clr_module.py,sha256=Mo13Of3DVSA5HR-5xZEXOiHApIKy52CUxtJ2gPkEu1A,3406
-pyedb/dotnet/edb.py,sha256=I9mgl1CZbJ-_hQNWPct3f3P7m4Sm1KTsMN6Ko6njXmw,172980
+pyedb/dotnet/edb.py,sha256=jSt794srQBzaxt3-iZqcv4ziOgNThWn46k3-V3svJqc,172798
 pyedb/dotnet/application/Variables.py,sha256=nov1kIyJO25iz8pvbU3MK1meMpRLwtISmzYqJhc7Ouo,79042
 pyedb/dotnet/application/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyedb/dotnet/edb_core/__init__.py,sha256=nIRLJ8VZLcMAp12zmGsnZ5x2BEEl7q_Kj_KAOXxVjpQ,52
@@ -31,8 +31,8 @@ pyedb/dotnet/edb_core/net_class.py,sha256=lr-7Z0Q1A2fshxwjrIOmQSZnEBYe0NoxuUuJT6
 pyedb/dotnet/edb_core/nets.py,sha256=ZQ5sk7cgTQJTbHd7JQa7MmBBV_crsWGtcLhKpSbfYMw,44042
 pyedb/dotnet/edb_core/obj_base.py,sha256=lufR0sZj0QfZ2wlNvLL6aM1KVqCNY2A7taPPdWcK20w,3312
 pyedb/dotnet/edb_core/padstack.py,sha256=PqXkSfyLRtdehm72sYiVMBUkNlDkivJ-eRoQWCzwNgw,57439
-pyedb/dotnet/edb_core/siwave.py,sha256=481ePzP0il60Bu_FqL2NcdcFTWNIBXd8OKnSigPefw8,62419
-pyedb/dotnet/edb_core/stackup.py,sha256=rg2LnxUyfd9Nnrj9uAd-0dkr65TQk7iMe0lS6cglaFc,122900
+pyedb/dotnet/edb_core/siwave.py,sha256=4v68zlCO-Czv8A3qtckfQ94jRFbMxM4kuoEDVRo_cmM,62495
+pyedb/dotnet/edb_core/stackup.py,sha256=Zko2gaotcJnILv_4SlZYzFc-NGblmTFBmEua7BSLcHU,122186
 pyedb/dotnet/edb_core/cell/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyedb/dotnet/edb_core/cell/hierarchy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyedb/dotnet/edb_core/cell/hierarchy/model.py,sha256=cJzNJLiuuoesfCL8-jWo8LbgGbfXrTYNQqmeeE38ieM,3309
@@ -54,10 +54,10 @@ pyedb/dotnet/edb_core/edb_data/design_options.py,sha256=RO9ip-T5Bfxpsl97_QEk0qDZ
 pyedb/dotnet/edb_core/edb_data/edbvalue.py,sha256=Vj_11HXsQUNavizKp5FicORm6cjhXRh9uvxhv_D_RJc,1977
 pyedb/dotnet/edb_core/edb_data/hfss_extent_info.py,sha256=5koQSKdYC6Deh4haLUDAxnHlRa-j5S6g4eyAfiGgZP8,13190
 pyedb/dotnet/edb_core/edb_data/hfss_pi_simulation_setup_data.py,sha256=v3z3h_27v3jRmDXqUjBS8P6UZMi-zuZQrZiYbE-RDw4,15657
-pyedb/dotnet/edb_core/edb_data/hfss_simulation_setup_data.py,sha256=rXzh95N_jLf6a3OEEJRm50qFX0rM6lS5B5osnKlVzf4,49037
-pyedb/dotnet/edb_core/edb_data/layer_data.py,sha256=HVPmE_Rny29J1c8qlJ3TSNZaMOTSxTgE9_vIiQJG0cE,25900
+pyedb/dotnet/edb_core/edb_data/hfss_simulation_setup_data.py,sha256=naka5Bm9Ditb6Cj_F1KMrxwGk8Cn2fPtnXlyGb9IY9E,49039
+pyedb/dotnet/edb_core/edb_data/layer_data.py,sha256=N3OIxdx1oeX3Lg1nmM-UcJ_8NQdaQD-_XgUEVlGLzOI,25918
 pyedb/dotnet/edb_core/edb_data/nets_data.py,sha256=iBegT3fa5DwvjD0Wfd-wlJztFrb33I5v6nzSUhNS6-I,10099
-pyedb/dotnet/edb_core/edb_data/padstacks_data.py,sha256=5qq4QohTLkwo-xfk2lXFM8Pria8ZYfZRc5B3XgdboGE,79342
+pyedb/dotnet/edb_core/edb_data/padstacks_data.py,sha256=IiF_wS9ZnyW-8W3wbcvinPAaL0LVuPGU74tHFZgZ1ZQ,79729
 pyedb/dotnet/edb_core/edb_data/ports.py,sha256=FYxB2rDUtN_OsYAbodXbc5mA_d0BUebmin_B5kkUw3U,9223
 pyedb/dotnet/edb_core/edb_data/primitives_data.py,sha256=veMDPCb6T84KZ_xgo52g7vHxObsx-Y2ysWXBS2CqZpQ,48155
 pyedb/dotnet/edb_core/edb_data/raptor_x_simulation_setup_data.py,sha256=Km1sjDVA0vSBOn8u2mMASPEGULQb3h-ZeSK-0Kymzqk,20962
@@ -75,7 +75,7 @@ pyedb/dotnet/edb_core/sim_setup_data/data/__init__.py,sha256=8jByHkoaowAYQTCww-z
 pyedb/dotnet/edb_core/sim_setup_data/data/siw_dc_ir_settings.py,sha256=b7Zpg6nNQArYxvdxlVhXDzvvCSC5sKFvdt10b0MHkvc,8605
 pyedb/dotnet/edb_core/utilities/__init__.py,sha256=8jByHkoaowAYQTCww-zRrTQmN061fLz_OHjTLSrzQQY,58
 pyedb/dotnet/edb_core/utilities/heatsink.py,sha256=7G7Yx9TxbL5EAiR51MnhdRiAQBVf-d0hKsXDw5OYX2Q,2220
-pyedb/dotnet/edb_core/utilities/simulation_setup.py,sha256=CsJxL8Q-tdgsybubB_HqIs9q8qJ675xp-ie9qh8kikE,25264
+pyedb/dotnet/edb_core/utilities/simulation_setup.py,sha256=ZU-HFdIqJ0DBQJqUHzU4-nzCHQ620h2ev7uR89ZFnqk,25256
 pyedb/generic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyedb/generic/constants.py,sha256=prWLZH0-SeBIVK6LHZ4SGZFQCofuym2TuQYfdqwhuSQ,28956
 pyedb/generic/data_handlers.py,sha256=oyYFwdjt0CxdOxgFDmnBlOFICt2twFLsMyELuQ1kFjE,7137
@@ -148,7 +148,7 @@ pyedb/misc/siw_feature_config/emc/tag_library.py,sha256=yUK4w3hequU017E2DbkA4KE2
 pyedb/misc/siw_feature_config/emc/xml_generic.py,sha256=55X-V0OxWq-v7FTiDVjaZif8V_2xxsvJlJ8bs9Bf61I,2521
 pyedb/modeler/geometry_operators.py,sha256=LDqEaeerw9H8Yva-SJhX3Afdni08OciO9t5G0c_tdqs,66820
 pyedb/siwave_core/icepak.py,sha256=WnZ-t8mik7LDY06V8hZFV-TxRZJQWK7bu_8Ichx-oBs,5206
-pyedb-0.11.2.dist-info/LICENSE,sha256=qQWivZ12ETN5l3QxvTARY-QI5eoRRlyHdwLlAj0Bg5I,1089
-pyedb-0.11.2.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
-pyedb-0.11.2.dist-info/METADATA,sha256=0SFV34c7Ruuce3RSxmS8ChPUdCVNsKZyhjja6m_2FXM,8354
-pyedb-0.11.2.dist-info/RECORD,,
+pyedb-0.12.1.dist-info/LICENSE,sha256=qQWivZ12ETN5l3QxvTARY-QI5eoRRlyHdwLlAj0Bg5I,1089
+pyedb-0.12.1.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+pyedb-0.12.1.dist-info/METADATA,sha256=sofDicuqDqxk_dG81zNz64hW00SYd41gY6FRyviOzpY,8354
+pyedb-0.12.1.dist-info/RECORD,,