pyedb 0.9.0__py3-none-any.whl → 0.10.dev0__py3-none-any.whl

pyedb/dotnet/edb_core/edb_data/layer_data.py

@@ -22,29 +22,126 @@
 
 from __future__ import absolute_import
 
-import re
-
 from pyedb.generic.general_methods import pyedb_function_handler
 
 
 class LayerEdbClass(object):
     """Manages Edb Layers. Replaces EDBLayer."""
 
-    def __init__(self, pclass, name):
-        self._pclass = pclass
+    def __init__(self, pedb, edb_object=None, name="", layer_type="undefined", **kwargs):
+        self._pedb = pedb
         self._name = name
         self._color = ()
         self._type = ""
 
+        if edb_object:
+            self._edb_object = edb_object.Clone()
+        else:
+            self._create(layer_type)
+            self.update(**kwargs)
+
+    @pyedb_function_handler
+    def _create(self, layer_type):
+        layer_type = self._layer_name_mapping[layer_type]
+        layer_type = self._doc_layer_mapping[layer_type]
+
+        self._edb_object = self._pedb.edb_api.cell._cell.Layer(
+            self._name,
+            layer_type,
+        )
+
+    @pyedb_function_handler
+    def update(self, **kwargs):
+        for k, v in kwargs.items():
+            if k in dir(self):
+                self.__setattr__(k, v)
+            else:
+                self._pedb.logger.error(f"{k} is not a valid layer attribute")
+
+    @property
+    def id(self):
+        return self._edb_object.GetLayerId()
+
+    @property
+    def fill_material(self):
+        """The layer's fill material."""
+        return self._edb_object.GetFillMaterial(True)
+
+    @fill_material.setter
+    def fill_material(self, value):
+        self._edb_object.SetFillMaterial(value)
+
+    @property
+    def _stackup_layer_mapping(self):
+        return {
+            "SignalLayer": self._edb.cell.layer_type.SignalLayer,
+            "DielectricLayer": self._edb.cell.layer_type.DielectricLayer,
+        }
+
+    @property
+    def _doc_layer_mapping(self):
+        return {
+            "ConductingLayer": self._edb.cell.layer_type.ConductingLayer,
+            "AirlinesLayer": self._edb.cell.layer_type.AirlinesLayer,
+            "ErrorsLayer": self._edb.cell.layer_type.ErrorsLayer,
+            "SymbolLayer": self._edb.cell.layer_type.SymbolLayer,
+            "MeasureLayer": self._edb.cell.layer_type.MeasureLayer,
+            "AssemblyLayer": self._edb.cell.layer_type.AssemblyLayer,
+            "SilkscreenLayer": self._edb.cell.layer_type.SilkscreenLayer,
+            "SolderMaskLayer": self._edb.cell.layer_type.SolderMaskLayer,
+            "SolderPasteLayer": self._edb.cell.layer_type.SolderPasteLayer,
+            "GlueLayer": self._edb.cell.layer_type.GlueLayer,
+            "WirebondLayer": self._edb.cell.layer_type.WirebondLayer,
+            "UserLayer": self._edb.cell.layer_type.UserLayer,
+            "SIwaveHFSSSolverRegions": self._edb.cell.layer_type.SIwaveHFSSSolverRegions,
+            "PostprocessingLayer": self._edb.cell.layer_type.PostprocessingLayer,
+            "OutlineLayer": self._edb.cell.layer_type.OutlineLayer,
+            "LayerTypesCount": self._edb.cell.layer_type.LayerTypesCount,
+            "UndefinedLayerType": self._edb.cell.layer_type.UndefinedLayerType,
+        }
+
+    @property
+    def _layer_type_mapping(self):
+        mapping = {}
+        mapping.update(self._stackup_layer_mapping)
+        mapping.update(self._doc_layer_mapping)
+        return mapping
+
+    @property
+    def _layer_name_mapping(self):
+        return {
+            "signal": "SignalLayer",
+            "dielectric": "DielectricLayer",
+            "conducting": "ConductingLayer",
+            "airlines": "AirlinesLayer",
+            "errors": "ErrorsLayer",
+            "symbol": "SymbolLayer",
+            "measure": "MeasureLayer",
+            "assembly": "AssemblyLayer",
+            "silkscreen": "SilkscreenLayer",
+            "soldermask": "SolderMaskLayer",
+            "solderpaste": "SolderPasteLayer",
+            "glue": "GlueLayer",
+            "wirebound": "WirebondLayer",
+            "user": "UserLayer",
+            "siwavehfsssolverregions": "SIwaveHFSSSolverRegions",
+            "postprocessing": "PostprocessingLayer",
+            "outline": "OutlineLayer",
+            "layertypescount": "LayerTypesCount",
+            "undefined": "UndefinedLayerType",
+        }
+
+    @property
+    def _layer_name_mapping_reversed(self):
+        return {j: i for i, j in self._layer_name_mapping.items()}
+
     @property
     def _edb(self):
-        return self._pclass._pedb.edb_api
+        return self._pedb.edb_api
 
     @property
     def _edb_layer(self):
-        for l in self._pclass._edb_layer_list:
-            if l.GetName() == self._name:
-                return l.Clone()
+        return self._edb_object
 
     @property
     def is_stackup_layer(self):
@@ -84,7 +181,7 @@ class LayerEdbClass(object):
     def color(self, rgb):
         layer_clone = self._edb_layer
         layer_clone.SetColor(*rgb)
-        self._pclass._set_layout_stackup(layer_clone, "change_attribute")
+        self._pedb.stackup._set_layout_stackup(layer_clone, "change_attribute")
         self._color = rgb
 
     @property
@@ -102,7 +199,7 @@ class LayerEdbClass(object):
     def transparency(self, trans):
         layer_clone = self._edb_layer
         layer_clone.SetTransparency(trans)
-        self._pclass._set_layout_stackup(layer_clone, "change_attribute")
+        self._pedb.stackup._set_layout_stackup(layer_clone, "change_attribute")
 
     @property
     def name(self):
@@ -119,35 +216,28 @@ class LayerEdbClass(object):
         layer_clone = self._edb_layer
         old_name = layer_clone.GetName()
         layer_clone.SetName(name)
-        self._pclass._set_layout_stackup(layer_clone, "change_name", self._name)
+        self._pedb.stackup._set_layout_stackup(layer_clone, "change_name", self._name)
         self._name = name
-        for padstack_def in list(self._pclass._pedb.padstacks.definitions.values()):
+        for padstack_def in list(self._pedb.padstacks.definitions.values()):
             padstack_def._update_layer_names(old_name=old_name, updated_name=name)
 
     @property
     def type(self):
         """Retrieve type of the layer."""
-        return re.sub(r"Layer$", "", self._edb_layer.GetLayerType().ToString()).lower()
+        return self._layer_name_mapping_reversed[self._edb_layer.GetLayerType().ToString()]
 
     @type.setter
-    def type(self, new_type):
-        if new_type == self.type:
-            return
+    def type(self, value):
+        value = self._layer_name_mapping[value]
         layer_clone = self._edb_layer
-        if new_type == "signal":
-            layer_clone.SetLayerType(self._edb.cell.layer_type.SignalLayer)
-            self._type = new_type
-        elif new_type == "dielectric":
-            layer_clone.SetLayerType(self._edb.cell.layer_type.DielectricLayer)
-            self._type = new_type
-        else:
-            return
-        self._pclass._set_layout_stackup(layer_clone, "change_attribute")
+        layer_clone.SetLayerType(self._layer_type_mapping[value])
+        self._type = value
+        self._pedb.stackup._set_layout_stackup(layer_clone, "change_attribute")
 
 
 class StackupLayerEdbClass(LayerEdbClass):
-    def __init__(self, pclass, name):
-        super().__init__(pclass, name)
+    def __init__(self, pedb, edb_object=None, name="", layer_type="signal", **kwargs):
+        super().__init__(pedb, edb_object, name=name, layer_type=layer_type, **kwargs)
         self._material = ""
         self._conductivity = 0.0
         self._permittivity = 0.0
@@ -166,6 +256,17 @@ class StackupLayerEdbClass(LayerEdbClass):
         self._upper_elevation = 0.0
         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]
+        self._edb_object = self._pedb.edb_api.cell._cell.StackupLayer(
+            self._name,
+            layer_type,
+            self._pedb.edb_value(0),
+            self._pedb.edb_value(0),
+            "copper",
+        )
+
     @property
     def lower_elevation(self):
         """Lower elevation.
@@ -180,10 +281,10 @@ class StackupLayerEdbClass(LayerEdbClass):
 
     @lower_elevation.setter
     def lower_elevation(self, value):
-        if self._pclass.mode == "Overlapping":
+        if self._pedb.stackup.mode == "Overlapping":
             layer_clone = self._edb_layer
-            layer_clone.SetLowerElevation(self._pclass._edb_value(value))
-            self._pclass._set_layout_stackup(layer_clone, "change_attribute")
+            layer_clone.SetLowerElevation(self._pedb.stackup._edb_value(value))
+            self._pedb.stackup._set_layout_stackup(layer_clone, "change_attribute")
 
     @property
     def upper_elevation(self):
@@ -212,7 +313,7 @@ class StackupLayerEdbClass(LayerEdbClass):
     def is_negative(self, value):
         layer_clone = self._edb_layer
         layer_clone.SetNegative(value)
-        self._pclass._set_layout_stackup(layer_clone, "change_attribute")
+        self._pedb.stackup._set_layout_stackup(layer_clone, "change_attribute")
 
     @property
     def material(self):
@@ -228,7 +329,7 @@ class StackupLayerEdbClass(LayerEdbClass):
     def material(self, name):
         layer_clone = self._edb_layer
         layer_clone.SetMaterial(name)
-        self._pclass._set_layout_stackup(layer_clone, "change_attribute")
+        self._pedb.stackup._set_layout_stackup(layer_clone, "change_attribute")
         self._material = name
 
     @property
@@ -239,8 +340,8 @@ class StackupLayerEdbClass(LayerEdbClass):
         -------
         float
         """
-        if self.material in self._pclass._pedb.materials.materials:
-            self._conductivity = self._pclass._pedb.materials[self.material].conductivity
+        if self.material in self._pedb.materials.materials:
+            self._conductivity = self._pedb.materials[self.material].conductivity
             return self._conductivity
 
         return None
@@ -253,8 +354,8 @@ class StackupLayerEdbClass(LayerEdbClass):
         -------
         float
         """
-        if self.material in self._pclass._pedb.materials.materials:
-            self._permittivity = self._pclass._pedb.materials[self.material].permittivity
+        if self.material in self._pedb.materials.materials:
+            self._permittivity = self._pedb.materials[self.material].permittivity
             return self._permittivity
         return None
 
@@ -266,8 +367,8 @@ class StackupLayerEdbClass(LayerEdbClass):
         -------
         float
         """
-        if self.material in self._pclass._pedb.materials.materials:
-            self._loss_tangent = self._pclass._pedb.materials[self.material].loss_tangent
+        if self.material in self._pedb.materials.materials:
+            self._loss_tangent = self._pedb.materials[self.material].loss_tangent
             return self._loss_tangent
         return None
 
@@ -282,10 +383,11 @@ class StackupLayerEdbClass(LayerEdbClass):
 
     @dielectric_fill.setter
     def dielectric_fill(self, name):
+        name = name.lower()
         if self.type == "signal":
             layer_clone = self._edb_layer
             layer_clone.SetFillMaterial(name)
-            self._pclass._set_layout_stackup(layer_clone, "change_attribute")
+            self._pedb.stackup._set_layout_stackup(layer_clone, "change_attribute")
             self._dielectric_fill = name
         else:
             pass
@@ -308,8 +410,8 @@ class StackupLayerEdbClass(LayerEdbClass):
         if not self.is_stackup_layer:  # pragma: no cover
             return
         layer_clone = self._edb_layer
-        layer_clone.SetThickness(self._pclass._edb_value(value))
-        self._pclass._set_layout_stackup(layer_clone, "change_attribute")
+        layer_clone.SetThickness(self._pedb.stackup._edb_value(value))
+        self._pedb.stackup._set_layout_stackup(layer_clone, "change_attribute")
         self._thickness = value
 
     @property
@@ -333,8 +435,8 @@ class StackupLayerEdbClass(LayerEdbClass):
         else:
             layer_clone = self._edb_layer
             layer_clone.SetEtchFactorEnabled(True)
-            layer_clone.SetEtchFactor(self._pclass._edb_value(value))
-        self._pclass._set_layout_stackup(layer_clone, "change_attribute")
+            layer_clone.SetEtchFactor(self._pedb.stackup._edb_value(value))
+        self._pedb.stackup._set_layout_stackup(layer_clone, "change_attribute")
         self._etch_factor = value
 
     @property
@@ -358,12 +460,12 @@ class StackupLayerEdbClass(LayerEdbClass):
         if set_enable:
             layer_clone = self._edb_layer
             layer_clone.SetRoughnessEnabled(True)
-            self._pclass._set_layout_stackup(layer_clone, "change_attribute")
+            self._pedb.stackup._set_layout_stackup(layer_clone, "change_attribute")
             self.assign_roughness_model()
         else:
             layer_clone = self._edb_layer
             layer_clone.SetRoughnessEnabled(False)
-            self._pclass._set_layout_stackup(layer_clone, "change_attribute")
+            self._pedb.stackup._set_layout_stackup(layer_clone, "change_attribute")
 
     @property
     def top_hallhuray_nodule_radius(self):
@@ -454,11 +556,11 @@ class StackupLayerEdbClass(LayerEdbClass):
         if not self.is_stackup_layer:  # pragma: no cover
             return
         if surface == "top":
-            return self._edb_layer.GetRoughnessModel(self._pclass._pedb.edb_api.Cell.RoughnessModel.Region.Top)
+            return self._edb_layer.GetRoughnessModel(self._pedb.edb_api.Cell.RoughnessModel.Region.Top)
         elif surface == "bottom":
-            return self._edb_layer.GetRoughnessModel(self._pclass._pedb.edb_api.Cell.RoughnessModel.Region.Bottom)
+            return self._edb_layer.GetRoughnessModel(self._pedb.edb_api.Cell.RoughnessModel.Region.Bottom)
         elif surface == "side":
-            return self._edb_layer.GetRoughnessModel(self._pclass._pedb.edb_api.Cell.RoughnessModel.Region.Side)
+            return self._edb_layer.GetRoughnessModel(self._pedb.edb_api.Cell.RoughnessModel.Region.Side)
 
     @pyedb_function_handler()
     def assign_roughness_model(
@@ -492,38 +594,38 @@ class StackupLayerEdbClass(LayerEdbClass):
         if not self.is_stackup_layer:  # pragma: no cover
             return
 
-        radius = self._pclass._edb_value(huray_radius)
+        radius = self._pedb.stackup._edb_value(huray_radius)
         self._hurray_nodule_radius = huray_radius
-        surface_ratio = self._pclass._edb_value(huray_surface_ratio)
+        surface_ratio = self._pedb.stackup._edb_value(huray_surface_ratio)
         self._hurray_surface_ratio = huray_surface_ratio
-        groisse_roughness = self._pclass._edb_value(groisse_roughness)
+        groisse_roughness = self._pedb.stackup._edb_value(groisse_roughness)
         regions = []
         if apply_on_surface == "all":
             self._side_roughness = "all"
             regions = [
-                self._pclass._pedb.edb_api.Cell.RoughnessModel.Region.Top,
-                self._pclass._pedb.edb_api.Cell.RoughnessModel.Region.Side,
-                self._pclass._pedb.edb_api.Cell.RoughnessModel.Region.Bottom,
+                self._pedb.edb_api.Cell.RoughnessModel.Region.Top,
+                self._pedb.edb_api.Cell.RoughnessModel.Region.Side,
+                self._pedb.edb_api.Cell.RoughnessModel.Region.Bottom,
             ]
         elif apply_on_surface == "top":
             self._side_roughness = "top"
-            regions = [self._pclass._pedb.edb_api.Cell.RoughnessModel.Region.Top]
+            regions = [self._pedb.edb_api.Cell.RoughnessModel.Region.Top]
         elif apply_on_surface == "bottom":
             self._side_roughness = "bottom"
-            regions = [self._pclass._pedb.edb_api.Cell.RoughnessModel.Region.Bottom]
+            regions = [self._pedb.edb_api.Cell.RoughnessModel.Region.Bottom]
         elif apply_on_surface == "side":
             self._side_roughness = "side"
-            regions = [self._pclass._pedb.edb_api.Cell.RoughnessModel.Region.Side]
+            regions = [self._pedb.edb_api.Cell.RoughnessModel.Region.Side]
 
         layer_clone = self._edb_layer
         layer_clone.SetRoughnessEnabled(True)
         for r in regions:
             if model_type == "huray":
-                model = self._pclass._pedb.edb_api.Cell.HurrayRoughnessModel(radius, surface_ratio)
+                model = self._pedb.edb_api.Cell.HurrayRoughnessModel(radius, surface_ratio)
             else:
-                model = self._pclass._pedb.edb_api.Cell.GroisseRoughnessModel(groisse_roughness)
+                model = self._pedb.edb_api.Cell.GroisseRoughnessModel(groisse_roughness)
             layer_clone.SetRoughnessModel(r, model)
-        return self._pclass._set_layout_stackup(layer_clone, "change_attribute")
+        return self._pedb.stackup._set_layout_stackup(layer_clone, "change_attribute")
 
     @pyedb_function_handler()
     def _json_format(self):
@@ -564,7 +666,7 @@ class StackupLayerEdbClass(LayerEdbClass):
                 material_data = layer["material"]
                 if material_data is not None:
                     material_name = layer["material"]["name"]
-                    self._pclass._pedb.materials.add_material(material_name, **material_data)
+                    self._pedb.materials.add_material(material_name, **material_data)
                     self.material = material_name
             if layer["dielectric_fill"]:
                 if isinstance(layer["dielectric_fill"], str):
@@ -572,7 +674,7 @@ class StackupLayerEdbClass(LayerEdbClass):
                 else:
                     dielectric_data = layer["dielectric_fill"]
                     if dielectric_data is not None:
-                        self._pclass._pedb.materials.add_material(**dielectric_data)
+                        self._pedb.materials.add_material(**dielectric_data)
                     self.dielectric_fill = layer["dielectric_fill"]["name"]
             self.thickness = layer["thickness"]
             self.etch_factor = layer["etch_factor"]

pyedb/dotnet/edb_core/edb_data/simulation_configuration.py

@@ -25,6 +25,7 @@ import json
 import os
 
 from pyedb.dotnet.clr_module import Dictionary
+from pyedb.dotnet.edb_core.edb_data.hfss_simulation_setup_data import AdaptiveType
 from pyedb.dotnet.edb_core.edb_data.sources import Source, SourceType
 from pyedb.generic.constants import (
     BasisOrder,
@@ -1249,6 +1250,9 @@ class SimulationConfigurationAc(object):
         self._snap_length_threshold = "2.5um"
         self._min_plane_area_to_mesh = "4mil2"  # Newly Added
         self._mesh_sizefactor = 0.0
+        self._adaptive_type = AdaptiveType.SingleFrequency
+        self._adaptive_low_freq = "0GHz"
+        self._adaptive_high_freq = "20GHz"
 
     @property
     def sweep_interpolating(self):  # pragma: no cover
@@ -1902,6 +1906,51 @@ class SimulationConfigurationAc(object):
             if value > 0.0:
                 self._do_lambda_refinement = False
 
+    @property
+    def adaptive_type(self):
+        """HFSS adaptive type.
+
+        Returns
+        -------
+        class: pyedb.dotnet.edb_core.edb_data.hfss_simulation_setup_data.AdaptiveType
+        """
+        return self._adaptive_type
+
+    @adaptive_type.setter
+    def adaptive_type(self, value):
+        if isinstance(value, int) and value in range(3):
+            self._adaptive_type = value
+
+    @property
+    def adaptive_low_freq(self):
+        """HFSS broadband low frequency adaptive meshing.
+
+        Returns
+        -------
+        str
+        """
+        return self._adaptive_low_freq
+
+    @adaptive_low_freq.setter
+    def adaptive_low_freq(self, value):
+        if isinstance(value, str):
+            self._adaptive_low_freq = value
+
+    @property
+    def adaptive_high_freq(self):
+        """HFSS broadband high frequency adaptive meshing.
+
+        Returns
+        -------
+        str
+        """
+        return self._adaptive_high_freq
+
+    @adaptive_high_freq.setter
+    def adaptive_high_freq(self, value):
+        if isinstance(value, str):
+            self._adaptive_high_freq = value
+
 
 class SimulationConfiguration(object):
     """Provides an ASCII simulation configuration file parser.

pyedb/dotnet/edb_core/hfss.py

@@ -1276,25 +1276,43 @@ class EdbHfss(object):
                                as argument"
             )
             return False
-        adapt = self._pedb.simsetupdata.AdaptiveFrequencyData()
-        adapt.AdaptiveFrequency = simulation_setup.mesh_freq
-        adapt.MaxPasses = int(simulation_setup.max_num_passes)
-        adapt.MaxDelta = str(simulation_setup.max_mag_delta_s)
         simsetup_info = self._pedb.simsetupdata.SimSetupInfo[self._pedb.simsetupdata.HFSSSimulationSettings]()
         simsetup_info.Name = simulation_setup.setup_name
 
+        if simulation_setup.ac_settings.adaptive_type == 0:
+            adapt = self._pedb.simsetupdata.AdaptiveFrequencyData()
+            adapt.AdaptiveFrequency = simulation_setup.mesh_freq
+            adapt.MaxPasses = int(simulation_setup.max_num_passes)
+            adapt.MaxDelta = str(simulation_setup.max_mag_delta_s)
+            if is_ironpython:
+                simsetup_info.SimulationSettings.AdaptiveSettings.AdaptiveFrequencyDataList.Clear()
+                simsetup_info.SimulationSettings.AdaptiveSettings.AdaptiveFrequencyDataList.Add(adapt)
+            else:
+                simsetup_info.SimulationSettings.AdaptiveSettings.AdaptiveFrequencyDataList = (
+                    convert_py_list_to_net_list([adapt])
+                )
+        elif simulation_setup.ac_settings.adaptive_type == 2:
+            low_freq_adapt_data = self._pedb.simsetupdata.AdaptiveFrequencyData()
+            low_freq_adapt_data.MaxDelta = str(simulation_setup.max_mag_delta_s)
+            low_freq_adapt_data.MaxPasses = int(simulation_setup.max_num_passes)
+            low_freq_adapt_data.AdaptiveFrequency = simulation_setup.ac_settings.adaptive_low_freq
+            high_freq_adapt_data = self._pedb.simsetupdata.AdaptiveFrequencyData()
+            high_freq_adapt_data.MaxDelta = str(simulation_setup.max_mag_delta_s)
+            high_freq_adapt_data.MaxPasses = int(simulation_setup.max_num_passes)
+            high_freq_adapt_data.AdaptiveFrequency = simulation_setup.ac_settings.adaptive_high_freq
+            simsetup_info.SimulationSettings.AdaptiveSettings.AdaptType = (
+                self._pedb.simsetupdata.AdaptiveSettings.TAdaptType.kBroadband
+            )
+            simsetup_info.SimulationSettings.AdaptiveSettings.AdaptiveFrequencyDataList.Clear()
+            simsetup_info.SimulationSettings.AdaptiveSettings.AdaptiveFrequencyDataList.Add(low_freq_adapt_data)
+            simsetup_info.SimulationSettings.AdaptiveSettings.AdaptiveFrequencyDataList.Add(high_freq_adapt_data)
+
         simsetup_info.SimulationSettings.CurveApproxSettings.ArcAngle = simulation_setup.arc_angle
         simsetup_info.SimulationSettings.CurveApproxSettings.UseArcToChordError = (
             simulation_setup.use_arc_to_chord_error
         )
         simsetup_info.SimulationSettings.CurveApproxSettings.ArcToChordError = simulation_setup.arc_to_chord_error
-        if is_ironpython:
-            simsetup_info.SimulationSettings.AdaptiveSettings.AdaptiveFrequencyDataList.Clear()
-            simsetup_info.SimulationSettings.AdaptiveSettings.AdaptiveFrequencyDataList.Add(adapt)
-        else:
-            simsetup_info.SimulationSettings.AdaptiveSettings.AdaptiveFrequencyDataList = convert_py_list_to_net_list(
-                [adapt]
-            )
+
         simsetup_info.SimulationSettings.InitialMeshSettings.LambdaRefine = simulation_setup.do_lambda_refinement
         if simulation_setup.mesh_sizefactor > 0.0:
             simsetup_info.SimulationSettings.InitialMeshSettings.MeshSizefactor = simulation_setup.mesh_sizefactor