pyedb 0.31.0__py3-none-any.whl → 0.34.0__py3-none-any.whl

pyedb/dotnet/edb_core/edb_data/nets_data.py

@@ -113,8 +113,9 @@ class EDBNetsData(NetDotNet):
         show_legend=True,
         save_plot=None,
         outline=None,
-        size=(2000, 1000),
+        size=(6000, 3000),
         show=True,
+        plot_vias=True,
     ):
         """Plot a net to Matplotlib 2D chart.
 
@@ -134,6 +135,9 @@ class EDBNetsData(NetDotNet):
             Image size in pixel (width, height).
         show : bool, optional
             Whether to show the plot or not. Default is `True`.
+        plot_vias : bool, optional
+            Whether to plot vias or not. It may impact on performances.
+            Default is `True`.
         """
 
         return self._app.nets.plot(
@@ -144,6 +148,7 @@ class EDBNetsData(NetDotNet):
             outline=outline,
             size=size,
             show=show,
+            plot_vias=plot_vias,
         )
 
     def get_smallest_trace_width(self):

pyedb/dotnet/edb_core/edb_data/padstacks_data.py

@@ -411,17 +411,6 @@ class EDBPadstack(object):
     >>> edb_padstack = edb.padstacks.definitions["MyPad"]
     """
 
-    PAD_SHAPE_PARAMETERS = {
-        "circle": ["diameter"],
-        "square": ["size"],
-        "rectangle": ["x_size", "y_size"],
-        "oval": ["x_size", "y_size", "corner_radius"],
-        "bullet": ["x_size", "y_size", "corner_radius"],
-        "round45": ["inner", "channel_width", "isolation_gap"],
-        "round90": ["inner", "channel_width", "isolation_gap"],
-        "no_geometry": [],
-    }
-
     def __init__(self, edb_padstack, ppadstack):
         self._edb_object = edb_padstack
         self.edb_padstack = edb_padstack
@@ -468,175 +457,6 @@ class EDBPadstack(object):
     def _padstack_def_data(self, value):
         self._edb_object.SetData(value)
 
-    @property
-    def pad_parameters(self) -> dict:
-        """Pad parameters.
-
-        Returns
-        -------
-        dict
-            params = {
-            'regular_pad': [
-                {'layer_name': '1_Top', 'shape': 'circle', 'offset_x': '0.1mm', 'offset_y': '0', 'rotation': '0',
-                 'diameter': '0.5mm'}
-            ],
-            'anti_pad': [
-                {'layer_name': '1_Top', 'shape': 'circle', 'offset_x': '0', 'offset_y': '0', 'rotation': '0',
-                'diameter': '1mm'}
-            ],
-            'thermal_pad': [
-                {'layer_name': '1_Top', 'shape': 'round90', 'offset_x': '0', 'offset_y': '0', 'rotation': '0',
-                'inner': '1mm', 'channel_width': '0.2mm', 'isolation_gap': '0.3mm'},
-            ],
-            'hole': [
-                {'layer_name': '1_Top', 'shape': 'circle', 'offset_x': '0', 'offset_y': '0', 'rotation': '0',
-                 'diameter': '0.1499997mm'},
-            ]
-        }
-        """
-        pdef_data = self._padstack_def_data
-        pad_type_list = [
-            self._ppadstack._pedb._edb.Definition.PadType.RegularPad,
-            self._ppadstack._pedb._edb.Definition.PadType.AntiPad,
-            self._ppadstack._pedb._edb.Definition.PadType.ThermalPad,
-            # self._ppadstack._pedb._edb.Definition.PadType.Hole,
-            # This property doesn't appear in UI. It is unclear what it is used for. Suppressing this property for now.
-        ]
-        data = {}
-        for pad_type in pad_type_list:
-            pad_type_name = pascal_to_snake(pad_type.ToString())
-            temp_list = []
-            for lyr_name in list(pdef_data.GetLayerNames()):
-                result = pdef_data.GetPadParametersValue(lyr_name, pad_type)
-                _, pad_shape, params, offset_x, offset_y, rotation = result
-                pad_shape = pascal_to_snake(pad_shape.ToString())
-
-                pad_params = {}
-                pad_params["layer_name"] = lyr_name
-                pad_params["shape"] = pad_shape
-                pad_params["offset_x"] = offset_x.ToString()
-                pad_params["offset_y"] = offset_y.ToString()
-                pad_params["rotation"] = rotation.ToString()
-
-                for idx, i in enumerate(self.PAD_SHAPE_PARAMETERS[pad_shape]):
-                    pad_params[i] = params[idx].ToString()
-                temp_list.append(pad_params)
-            data[pad_type_name] = temp_list
-        return data
-
-    @pad_parameters.setter
-    def pad_parameters(self, params: dict):
-        original_params = self.pad_parameters
-        pdef_data = self._padstack_def_data
-
-        pad_type_list = [
-            self._ppadstack._pedb._edb.Definition.PadType.RegularPad,
-            self._ppadstack._pedb._edb.Definition.PadType.AntiPad,
-            self._ppadstack._pedb._edb.Definition.PadType.ThermalPad,
-            self._ppadstack._pedb._edb.Definition.PadType.Hole,
-        ]
-        for pad_type in pad_type_list:
-            pad_type_name = pascal_to_snake(pad_type.ToString())
-            rpp = params.get(pad_type_name, [])
-            for idx, layer_data in enumerate(rpp):
-                # Get geometry type from kwargs
-                p = layer_data.get("shape")
-                temp_param = []
-
-                # Handle Circle geometry type
-                if p == pascal_to_snake(self._ppadstack._pedb._edb.Definition.PadGeometryType.Circle.ToString()):
-                    temp_param.append(layer_data["diameter"])
-                    pad_shape = self._ppadstack._pedb._edb.Definition.PadGeometryType.Circle
-
-                # Handle Square geometry type
-                elif p == pascal_to_snake(self._ppadstack._pedb._edb.Definition.PadGeometryType.Square.ToString()):
-                    temp_param.append(layer_data["size"])
-                    pad_shape = self._ppadstack._pedb._edb.Definition.PadGeometryType.Square
-
-                elif p == pascal_to_snake(self._ppadstack._pedb._edb.Definition.PadGeometryType.Rectangle.ToString()):
-                    temp_param.append(layer_data["x_size"])
-                    temp_param.append(layer_data["y_size"])
-                    pad_shape = self._ppadstack._pedb._edb.Definition.PadGeometryType.Rectangle
-
-                # Handle Oval geometry type
-                elif p == pascal_to_snake(self._ppadstack._pedb._edb.Definition.PadGeometryType.Oval.ToString()):
-                    temp_param.append(layer_data["x_size"])
-                    temp_param.append(layer_data["y_size"])
-                    temp_param.append(layer_data["corner_radius"])
-                    pad_shape = self._ppadstack._pedb._edb.Definition.PadGeometryType.Oval
-
-                # Handle Bullet geometry type
-                elif p == pascal_to_snake(self._ppadstack._pedb._edb.Definition.PadGeometryType.Bullet.ToString()):
-                    temp_param.append(layer_data["x_size"])
-                    temp_param.append(layer_data["y_size"])
-                    temp_param.append(layer_data["corner_radius"])
-                    pad_shape = self._ppadstack._pedb._edb.Definition.PadGeometryType.Bullet
-
-                # Handle Round45 geometry type
-                elif p == pascal_to_snake(self._ppadstack._pedb._edb.Definition.PadGeometryType.Round45.ToString()):
-                    temp_param.append(layer_data["inner"])
-                    temp_param.append(layer_data["channel_width"])
-                    temp_param.append(layer_data["isolation_gap"])
-                    pad_shape = self._ppadstack._pedb._edb.Definition.PadGeometryType.Round45
-
-                # Handle Round90 geometry type
-                elif p == pascal_to_snake(self._ppadstack._pedb._edb.Definition.PadGeometryType.Round90.ToString()):
-                    temp_param.append(layer_data["inner"])
-                    temp_param.append(layer_data["channel_width"])
-                    temp_param.append(layer_data["isolation_gap"])
-                    pad_shape = self._ppadstack._pedb._edb.Definition.PadGeometryType.Round90
-                elif p == pascal_to_snake(self._ppadstack._pedb._edb.Definition.PadGeometryType.NoGeometry.ToString()):
-                    continue
-
-                # Set pad parameters for the current layer
-                pdef_data.SetPadParameters(
-                    layer_data["layer_name"],
-                    pad_type,
-                    pad_shape,
-                    convert_py_list_to_net_list([self._ppadstack._pedb.edb_value(i) for i in temp_param]),
-                    self._ppadstack._pedb.edb_value(layer_data.get("offset_x", 0)),
-                    self._ppadstack._pedb.edb_value(layer_data.get("offset_y", 0)),
-                    self._ppadstack._pedb.edb_value(layer_data.get("rotation", 0)),
-                )
-        self._padstack_def_data = pdef_data
-
-    @property
-    def hole_parameters(self):
-        pdef_data = self._padstack_def_data
-        _, hole_shape, params, offset_x, offset_y, rotation = pdef_data.GetHoleParametersValue()
-        hole_shape = pascal_to_snake(hole_shape.ToString())
-
-        hole_params = {}
-        hole_params["shape"] = hole_shape
-        for idx, i in enumerate(self.PAD_SHAPE_PARAMETERS[hole_shape]):
-            hole_params[i] = params[idx].ToString()
-        hole_params["offset_x"] = offset_x.ToString()
-        hole_params["offset_y"] = offset_y.ToString()
-        hole_params["rotation"] = rotation.ToString()
-        return hole_params
-
-    @hole_parameters.setter
-    def hole_parameters(self, params: dict):
-        original_params = self.hole_parameters
-        pdef_data = self._padstack_def_data
-
-        temp_param = []
-        shape = params["shape"]
-        if shape == "no_geometry":
-            return  # .net api doesn't tell how to set no_geometry shape.
-        for idx, i in enumerate(self.PAD_SHAPE_PARAMETERS[shape]):
-            temp_param.append(params[i])
-            pedb_shape = getattr(self._ppadstack._pedb._edb.Definition.PadGeometryType, snake_to_pascal(shape))
-
-        pdef_data.SetHoleParameters(
-            pedb_shape,
-            convert_py_list_to_net_list([self._ppadstack._pedb.edb_value(i) for i in temp_param]),
-            self._ppadstack._pedb.edb_value(params.get("offset_x", original_params.get("offset_x", 0))),
-            self._ppadstack._pedb.edb_value(params.get("offset_y", original_params.get("offset_y", 0))),
-            self._ppadstack._pedb.edb_value(params.get("rotation", original_params.get("rotation", 0))),
-        )
-        self._padstack_def_data = pdef_data
-
     @property
     def instances(self):
         """Definitions Instances."""
@@ -1322,18 +1142,6 @@ class EDBPadstack(object):
         self.edb_padstack.SetData(new_padstack_data)
         return True
 
-    def set_properties(self, **kwargs):
-        for k in ["hole_plating_thickness", "material", "hole_range", "pad_parameters", "hole_parameters"]:
-            value = kwargs.get(k, False)
-            if value:
-                setattr(self, k, value)
-
-    def get_properties(self):
-        kwargs = {}
-        for k in ["hole_plating_thickness", "material", "hole_range", "pad_parameters", "hole_parameters"]:
-            kwargs[k] = getattr(self, k)
-        return kwargs
-
 
 class EDBPadstackInstance(Primitive):
     """Manages EDB functionalities for a padstack.
@@ -1583,6 +1391,17 @@ class EDBPadstackInstance(Primitive):
 
     @property
     def padstack_definition(self):
+        """Padstack definition Name.
+
+        Returns
+        -------
+        str
+            Name of the padstack definition.
+        """
+        return self.definition.name
+
+    @property
+    def definition(self):
         """Padstack definition.
 
         Returns
@@ -1590,7 +1409,7 @@ class EDBPadstackInstance(Primitive):
         str
             Name of the padstack definition.
         """
-        self._pdef = self._edb_padstackinstance.GetPadstackDef().GetName()
+        self._pdef = EDBPadstack(self._edb_padstackinstance.GetPadstackDef(), self._pedb.padstacks)
         return self._pdef
 
     @property
@@ -1975,6 +1794,10 @@ class EDBPadstackInstance(Primitive):
         name = str(name).strip("'")
         return name
 
+    @aedt_name.setter
+    def aedt_name(self, value):
+        self._edb_object.SetProductProperty(self._pedb.edb_api.ProductId.Designer, 11, value)
+
     def parametrize_position(self, prefix=None):
         """Parametrize the instance position.
 
@@ -2324,32 +2147,3 @@ class EDBPadstackInstance(Primitive):
             max_limit=max_limit,
             component_only=component_only,
         )
-
-    @property
-    def properties(self):
-        data = {}
-        data["name"] = self.aedt_name
-        data["definition"] = self.padstack_definition
-        data["backdrill_parameters"] = self.backdrill_parameters
-        _, position, rotation = self._edb_object.GetPositionAndRotationValue()
-        data["position"] = [position.X.ToString(), position.Y.ToString()]
-        data["rotation"] = [rotation.ToString()]
-        data["id"] = self.id
-        hole_override_enabled, hole_override_diam = self._edb_object.GetHoleOverrideValue()
-        data["hole_override_enabled"] = hole_override_enabled
-        data["hole_override_diameter"] = hole_override_diam.ToString()
-        return data
-
-    @properties.setter
-    def properties(self, params):
-        name = params.get("name", None)
-        if name:
-            self.aedt_name = name
-        backdrill_parameters = params.get("backdrill_parameters", None)
-        if backdrill_parameters:
-            self.backdrill_parameters = backdrill_parameters
-        h_o_enabled = params.get("hole_override_enabled", None)
-        h_o_enabled = h_o_enabled if h_o_enabled else self.properties["hole_override_enabled"]
-        h_o_diameter = params.get("hole_override_diameter")
-        h_o_diameter = h_o_diameter if h_o_diameter else self.properties["hole_override_diameter"]
-        self._edb_object.SetHoleOverride(h_o_enabled, self._pedb.edb_value(h_o_diameter))

pyedb/dotnet/edb_core/edb_data/primitives_data.py

@@ -29,6 +29,7 @@ from pyedb.dotnet.edb_core.dotnet.primitive import (
     RectangleDotNet,
     TextDotNet,
 )
+from pyedb.dotnet.edb_core.geometry.polygon_data import PolygonData
 from pyedb.modeler.geometry_operators import GeometryOperators
 
 
@@ -305,6 +306,36 @@ class EdbPolygon(Primitive):
     #         prim = point_list
     #     return self.add_void(prim)
 
+    @property
+    def polygon_data(self):
+        """:class:`pyedb.dotnet.edb_core.dotnet.database.PolygonDataDotNet`: Outer contour of the Polygon object."""
+        return PolygonData(self._pedb, self._edb_object.GetPolygonData())
+
+    @polygon_data.setter
+    def polygon_data(self, poly):
+        self._edb_object.SetPolygonData(poly._edb_object)
+
+    def expand(self, offset=0.001, tolerance=1e-12, round_corners=True, maximum_corner_extension=0.001):
+        """Expand the polygon shape by an absolute value in all direction.
+        Offset can be negative for negative expansion.
+
+        Parameters
+        ----------
+        offset : float, optional
+            Offset value in meters.
+        tolerance : float, optional
+            Tolerance in meters.
+        round_corners : bool, optional
+            Whether to round corners or not.
+            If True, use rounded corners in the expansion otherwise use straight edges (can be degenerate).
+        maximum_corner_extension : float, optional
+            The maximum corner extension (when round corners are not used) at which point the corner is clipped.
+        """
+        pd = self.polygon_data
+        pd.expand(offset, tolerance, round_corners, maximum_corner_extension)
+        self.polygon_data = pd
+        return pd
+
 
 class EdbText(Primitive, TextDotNet):
     def __init__(self, raw_primitive, core_app):

pyedb/dotnet/edb_core/hfss.py

@@ -1168,8 +1168,8 @@ class EdbHfss(object):
         list
             [lower left corner X, lower left corner, upper right corner X, upper right corner Y].
         """
-        if layout == None:
-            return False
+        if layout is None:
+            layout = self._active_layout
         layout_obj_instances = layout.GetLayoutInstance().GetAllLayoutObjInstances()
         tuple_list = []
         for lobj in layout_obj_instances.Items:

pyedb/dotnet/edb_core/layout_validation.py

@@ -332,9 +332,7 @@ class LayoutValidation:
                 counts += 1
                 if fix:
                     if not obj.component:
-                        obj._edb_object.SetProductProperty(
-                            self._pedb.edb_api.ProductId.Designer, 11, f"via_{via_count}"
-                        )
+                        obj._edb_object.SetProductProperty(self._pedb.edb_api.ProductId.Designer, 11, f"Via{via_count}")
                         via_count = via_count + 1
                     else:
                         obj._edb_object.SetProductProperty(

pyedb/dotnet/edb_core/materials.py

@@ -69,6 +69,7 @@ DC_ATTRIBUTES = [
     "dc_conductivity",
     "dc_permittivity",
 ]
+PERMEABILITY_DEFAULT_VALUE = 1
 
 
 def get_line_float_value(line):
@@ -114,7 +115,6 @@ class Material(object):
         self.__name: str = material_def.GetName()
         self.__material_def = material_def
         self.__dc_model = material_def.GetDielectricMaterialModel()
-        self.__properties: MaterialProperties = MaterialProperties()
 
     @property
     def name(self):
@@ -130,8 +130,7 @@ class Material(object):
     def conductivity(self):
         """Get material conductivity."""
         material_property_id = self.__edb_definition.MaterialPropertyId.Conductivity
-        self.__properties.conductivity = self.__property_value(material_property_id)
-        return self.__properties.conductivity
+        return self.__property_value(material_property_id)
 
     @conductivity.setter
     def conductivity(self, value):
@@ -144,8 +143,7 @@ class Material(object):
     def permittivity(self):
         """Get material permittivity."""
         material_property_id = self.__edb_definition.MaterialPropertyId.Permittivity
-        self.__properties.permittivity = self.__property_value(material_property_id)
-        return self.__properties.permittivity
+        return self.__property_value(material_property_id)
 
     @permittivity.setter
     def permittivity(self, value):
@@ -158,8 +156,7 @@ class Material(object):
     def permeability(self):
         """Get material permeability."""
         material_property_id = self.__edb_definition.MaterialPropertyId.Permeability
-        self.__properties.permeability = self.__property_value(material_property_id)
-        return self.__properties.permeability
+        return self.__property_value(material_property_id)
 
     @permeability.setter
     def permeability(self, value):
@@ -182,8 +179,7 @@ class Material(object):
     def dielectric_loss_tangent(self):
         """Get material loss tangent."""
         material_property_id = self.__edb_definition.MaterialPropertyId.DielectricLossTangent
-        self.__properties.dielectric_loss_tangent = self.__property_value(material_property_id)
-        return self.__properties.dielectric_loss_tangent
+        return self.__property_value(material_property_id)
 
     @loss_tangent.setter
     def loss_tangent(self, value):
@@ -205,9 +201,10 @@ class Material(object):
     @property
     def dc_conductivity(self):
         """Get material dielectric conductivity."""
+        res = None
         if self.__dc_model:
-            self.__properties.dc_conductivity = self.__dc_model.GetDCConductivity()
-        return self.__properties.dc_conductivity
+            res = self.__dc_model.GetDCConductivity()
+        return res
 
     @dc_conductivity.setter
     def dc_conductivity(self, value: Union[int, float]):
@@ -220,9 +217,10 @@ class Material(object):
     @property
     def dc_permittivity(self):
         """Get material dielectric relative permittivity"""
+        res = None
         if self.__dc_model:
-            self.__properties.dc_permittivity = self.__dc_model.GetDCRelativePermitivity()
-        return self.__properties.dc_permittivity
+            res = self.__dc_model.GetDCRelativePermitivity()
+        return res
 
     @dc_permittivity.setter
     def dc_permittivity(self, value: Union[int, float]):
@@ -237,9 +235,10 @@ class Material(object):
     @property
     def dielectric_model_frequency(self):
         """Get material frequency in GHz."""
+        res = None
         if self.__dc_model:
-            self.__properties.dielectric_model_frequency = self.__dc_model.GetFrequency()
-        return self.__properties.dielectric_model_frequency
+            res = self.__dc_model.GetFrequency()
+        return res
 
     @dielectric_model_frequency.setter
     def dielectric_model_frequency(self, value: Union[int, float]):
@@ -252,9 +251,10 @@ class Material(object):
     @property
     def loss_tangent_at_frequency(self):
         """Get material loss tangeat at frequency."""
+        res = None
         if self.__dc_model:
-            self.__properties.loss_tangent_at_frequency = self.__dc_model.GetLossTangentAtFrequency()
-        return self.__properties.loss_tangent_at_frequency
+            res = self.__dc_model.GetLossTangentAtFrequency()
+        return res
 
     @loss_tangent_at_frequency.setter
     def loss_tangent_at_frequency(self, value):
@@ -268,9 +268,10 @@ class Material(object):
     @property
     def permittivity_at_frequency(self):
         """Get material relative permittivity at frequency."""
+        res = None
         if self.__dc_model:
-            self.__properties.permittivity_at_frequency = self.__dc_model.GetRelativePermitivityAtFrequency()
-        return self.__properties.permittivity_at_frequency
+            res = self.__dc_model.GetRelativePermitivityAtFrequency()
+        return res
 
     @permittivity_at_frequency.setter
     def permittivity_at_frequency(self, value: Union[int, float]):
@@ -284,8 +285,7 @@ class Material(object):
     def magnetic_loss_tangent(self):
         """Get material magnetic loss tangent."""
         material_property_id = self.__edb_definition.MaterialPropertyId.MagneticLossTangent
-        self.__properties.magnetic_loss_tangent = self.__property_value(material_property_id)
-        return self.__properties.magnetic_loss_tangent
+        return self.__property_value(material_property_id)
 
     @magnetic_loss_tangent.setter
     def magnetic_loss_tangent(self, value):
@@ -298,8 +298,7 @@ class Material(object):
     def thermal_conductivity(self):
         """Get material thermal conductivity."""
         material_property_id = self.__edb_definition.MaterialPropertyId.ThermalConductivity
-        self.__properties.thermal_conductivity = self.__property_value(material_property_id)
-        return self.__properties.thermal_conductivity
+        return self.__property_value(material_property_id)
 
     @thermal_conductivity.setter
     def thermal_conductivity(self, value):
@@ -312,8 +311,7 @@ class Material(object):
     def mass_density(self):
         """Get material mass density."""
         material_property_id = self.__edb_definition.MaterialPropertyId.MassDensity
-        self.__properties.mass_density = self.__property_value(material_property_id)
-        return self.__properties.mass_density
+        return self.__property_value(material_property_id)
 
     @mass_density.setter
     def mass_density(self, value):
@@ -326,8 +324,7 @@ class Material(object):
     def youngs_modulus(self):
         """Get material youngs modulus."""
         material_property_id = self.__edb_definition.MaterialPropertyId.YoungsModulus
-        self.__properties.youngs_modulus = self.__property_value(material_property_id)
-        return self.__properties.youngs_modulus
+        return self.__property_value(material_property_id)
 
     @youngs_modulus.setter
     def youngs_modulus(self, value):
@@ -340,8 +337,7 @@ class Material(object):
     def specific_heat(self):
         """Get material specific heat."""
         material_property_id = self.__edb_definition.MaterialPropertyId.SpecificHeat
-        self.__properties.specific_heat = self.__property_value(material_property_id)
-        return self.__properties.specific_heat
+        return self.__property_value(material_property_id)
 
     @specific_heat.setter
     def specific_heat(self, value):
@@ -354,8 +350,7 @@ class Material(object):
     def poisson_ratio(self):
         """Get material poisson ratio."""
         material_property_id = self.__edb_definition.MaterialPropertyId.PoissonsRatio
-        self.__properties.poisson_ratio = self.__property_value(material_property_id)
-        return self.__properties.poisson_ratio
+        return self.__property_value(material_property_id)
 
     @poisson_ratio.setter
     def poisson_ratio(self, value):
@@ -368,8 +363,7 @@ class Material(object):
     def thermal_expansion_coefficient(self):
         """Get material thermal coefficient."""
         material_property_id = self.__edb_definition.MaterialPropertyId.ThermalExpansionCoefficient
-        self.__properties.thermal_expansion_coefficient = self.__property_value(material_property_id)
-        return self.__properties.thermal_expansion_coefficient
+        return self.__property_value(material_property_id)
 
     @thermal_expansion_coefficient.setter
     def thermal_expansion_coefficient(self, value):
@@ -380,10 +374,10 @@ class Material(object):
 
     def to_dict(self):
         """Convert material into dictionary."""
-        self.__load_all_properties()
+        properties = self.__load_all_properties()
 
         res = {"name": self.name}
-        res.update(self.__properties.model_dump())
+        res.update(properties.model_dump())
         return res
 
     def update(self, input_dict: dict):
@@ -419,10 +413,13 @@ class Material(object):
         """
         return self.__edb.edb_value(value)
 
-    def __load_all_properties(self):
+    def __load_all_properties(self) -> MaterialProperties:
         """Load all properties of the material."""
-        for property in self.__properties.model_dump().keys():
-            _ = getattr(self, property)
+        res = MaterialProperties()
+        for property in res.model_dump().keys():
+            value = getattr(self, property)
+            setattr(res, property, value)
+        return res
 
     def __property_value(self, material_property_id):
         """Get property value from a material property id."""
@@ -507,6 +504,9 @@ class Materials(object):
 
         material_def = self.__edb_definition.MaterialDef.Create(self.__edb.active_db, name)
         material = Material(self.__edb, material_def)
+        # Apply default values to the material
+        if "permeability" not in kwargs:
+            kwargs["permeability"] = PERMEABILITY_DEFAULT_VALUE
         attributes_input_dict = {key: val for (key, val) in kwargs.items() if key in ATTRIBUTES + DC_ATTRIBUTES}
         if "loss_tangent" in kwargs:  # pragma: no cover
             warnings.warn(

pyedb/dotnet/edb_core/modeler.py

@@ -188,7 +188,10 @@ class Modeler(object):
         for lay in self._pedb.stackup.non_stackup_layers:
             _primitives_by_layer[lay] = []
         for i in self._layout.primitives:
-            lay = i.layer.name
+            layer = i.layer
+            if not layer:
+                continue
+            lay = layer.name
             if lay in _primitives_by_layer:
                 _primitives_by_layer[lay].append(i)
         return _primitives_by_layer