pyedb 0.39.1__py3-none-any.whl → 0.41.0__py3-none-any.whl

pyedb/__init__.py

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

pyedb/common/nets.py

@@ -22,6 +22,7 @@ class CommonNets:
         show=True,
         annotate_component_names=True,
         plot_vias=False,
+        title=None,
         **kwargs,
     ):
         """Plot a Net to Matplotlib 2D Chart.
@@ -57,6 +58,9 @@ class CommonNets:
         plot_vias : bool, optional
             Whether to plot vias (circular and rectangular) or not. This may impact in the plot computation time.
             Default is ``False``.
+        title : str, optional
+            Specify the default plot title. Is value is ``None`` the project name is assigned by default. Default value
+            is ``None``.
         show : bool, optional
             Whether to show the plot or not. Default is `True`.
 
@@ -95,7 +99,7 @@ class CommonNets:
 
         start_time = time.time()
         if not nets:
-            nets = list(self.nets.keys())
+            nets = list(self._pedb.nets.nets.keys())
         if isinstance(nets, str):
             nets = [nets]
         if not layers:
@@ -395,7 +399,12 @@ class CommonNets:
         # Hide axes ticks
         ax.set_xticks([])
         ax.set_yticks([])
-        message = "Edb Top View" if top_view else "Edb Bottom View"
+        if not title:
+            if not self._pedb.grpc:
+                title = self._pedb.active_cell.GetName()
+            else:
+                title = self._pedb.active_cell.name
+        message = f"Edb Top View {title}" if top_view else f"Edb Bottom View {title}"
         plt.title(message, size=20)
         if show_legend:
             plt.legend(loc="upper left", fontsize="x-large")

pyedb/configuration/cfg_components.py

@@ -216,6 +216,7 @@ class CfgComponent(CfgBase):
             if self.pyedb_obj.type.lower() == "ic":
                 self._set_ic_die_properties_to_edb()
                 self._set_port_properties_to_edb()
+                self._set_solder_ball_properties_to_edb()
             elif self.pyedb_obj.type.lower() in ["io", "other"]:
                 self._set_solder_ball_properties_to_edb()
                 self._set_port_properties_to_edb()
@@ -228,6 +229,7 @@ class CfgComponent(CfgBase):
             if self.pyedb_obj.type.lower() == "ic":
                 self._retrieve_ic_die_properties_from_edb()
                 self._retrieve_port_properties_from_edb()
+                self._retrieve_solder_ball_properties_from_edb()
             elif self.pyedb_obj.type.lower() in ["io", "other"]:
                 self._retrieve_solder_ball_properties_from_edb()
                 self._retrieve_port_properties_from_edb()

pyedb/configuration/cfg_padstacks.py

@@ -427,7 +427,7 @@ class CfgPadstackInstance(CfgBase):
             self.api = self.DotNet(self)
 
         self.name = kwargs.get("name", None)
-        self.net_name = kwargs.get("net_name", "")
+        self.net_name = kwargs.get("net_name", None)
         self.layer_range = kwargs.get("layer_range", [None, None])
         self.definition = kwargs.get("definition", None)
         self.backdrill_parameters = kwargs.get("backdrill_parameters", None)

pyedb/configuration/cfg_ports_sources.py

@@ -24,6 +24,7 @@ import os
 import numpy as np
 
 from pyedb.configuration.cfg_common import CfgBase
+from pyedb.dotnet.database.cell.primitive.primitive import Primitive
 from pyedb.dotnet.database.edb_data.ports import WavePort
 from pyedb.dotnet.database.general import convert_py_list_to_net_list
 from pyedb.dotnet.database.geometry.point_data import PointData
@@ -53,6 +54,7 @@ class CfgTerminalInfo(CfgBase):
         contact_radius = "0.1mm" if kwargs.get("contact_radius") is None else kwargs.get("contact_radius")
         self.contact_radius = self._pedb.edb_value(contact_radius).ToDouble()
         self.num_of_contact = kwargs.get("num_of_contact", 4)
+        self.contact_expansion = kwargs.get("contact_expansion", 1)
 
     def export_properties(self):
         return {self.type: self.value}
@@ -141,7 +143,7 @@ class CfgPorts:
         self.ports = []
         for p in ports_data:
             if p["type"] == "wave_port":
-                self.ports.append(CfgWavePort(self._pedb, **p))
+                self.ports.append(CfgEdgePort(self._pedb, **p))
             elif p["type"] == "diff_wave_port":
                 self.ports.append(CfgDiffWavePort(self._pedb, **p))
             elif p["type"] in ["coax", "circuit"]:
@@ -167,7 +169,12 @@ class CfgPorts:
 
         for _, p in ports.items():
             if not p.ref_terminal:
-                port_type = "coax"
+                if p.terminal_type == "PadstackInstanceTerminal":
+                    port_type = "coax"
+                elif p.hfss_type == "Wave":
+                    port_type = "wave_port"
+                else:
+                    port_type = "gap_port"
             else:
                 port_type = "circuit"
 
@@ -206,7 +213,7 @@ class CfgPorts:
                     positive_terminal=pos_term_info,
                     negative_terminal=neg_term_info,
                 )
-            else:
+            elif port_type == "coax":
                 cfg_port = CfgPort(
                     self._pedb,
                     name=p.name,
@@ -214,6 +221,22 @@ class CfgPorts:
                     reference_designator=refdes,
                     positive_terminal=pos_term_info,
                 )
+            else:
+                _, primitive, point = p._edb_object.GetEdges()[0].GetParameters()
+
+                primitive = Primitive(self._pedb, primitive)
+                point = PointData(self._pedb, point)
+
+                cfg_port = CfgEdgePort(
+                    self._pedb,
+                    name=p.name,
+                    type=port_type,
+                    primitive_name=primitive.aedt_name,
+                    point_on_edge=[point._edb_object.X.ToString(), point._edb_object.Y.ToString()],
+                    horizontal_extent_factor=p.horizontal_extent_factor,
+                    vertical_extent_factor=p.vertical_extent_factor,
+                    pec_launch_width=p.pec_launch_width,
+                )
 
             self.ports.append(cfg_port)
         return self.export_properties()
@@ -294,7 +317,11 @@ class CfgCircuitElement(CfgBase):
                     contact_type = self.positive_terminal_info.contact_type
                     radius = self.positive_terminal_info.contact_radius
                     num_of_contact = self.positive_terminal_info.num_of_contact
-                    virtual_pins = self._create_virtual_pins_on_pin(pin, contact_type, radius, num_of_contact)
+                    contact_expansion = self.positive_terminal_info.contact_expansion
+
+                    virtual_pins = self._create_virtual_pins_on_pin(
+                        pin, contact_type, radius, num_of_contact, contact_expansion
+                    )
                     pos_objs.update(virtual_pins)
                     self._elem_num = len(pos_objs)
             else:
@@ -309,7 +336,11 @@ class CfgCircuitElement(CfgBase):
                     contact_type = self.positive_terminal_info.contact_type
                     radius = self.positive_terminal_info.contact_radius
                     num_of_contact = self.positive_terminal_info.num_of_contact
-                    virtual_pins = self._create_virtual_pins_on_pin(pin, contact_type, radius, num_of_contact)
+                    contact_expansion = self.positive_terminal_info.contact_expansion
+
+                    virtual_pins = self._create_virtual_pins_on_pin(
+                        pin, contact_type, radius, num_of_contact, contact_expansion
+                    )
                     pos_objs.update(virtual_pins)
                     self._elem_num = len(pos_objs)
             else:
@@ -324,7 +355,11 @@ class CfgCircuitElement(CfgBase):
                     contact_type = self.positive_terminal_info.contact_type
                     radius = self.positive_terminal_info.contact_radius
                     num_of_contact = self.positive_terminal_info.num_of_contact
-                    virtual_pins = self._create_virtual_pins_on_pin(pin, contact_type, radius, num_of_contact)
+                    contact_expansion = self.positive_terminal_info.contact_expansion
+
+                    virtual_pins = self._create_virtual_pins_on_pin(
+                        pin, contact_type, radius, num_of_contact, contact_expansion
+                    )
                     pos_objs.update(virtual_pins)
                     self._elem_num = len(pos_objs)
             else:
@@ -400,7 +435,7 @@ class CfgCircuitElement(CfgBase):
             pins.update({f"{reference_designator}_{terminal_value[0]}_{i}": j for i, j in temp.items()})
         return pins
 
-    def _create_virtual_pins_on_pin(self, pin, contact_type, radius, num_of_contact=4):
+    def _create_virtual_pins_on_pin(self, pin, contact_type, radius, num_of_contact=4, expansion=1):
         component = pin.component
         placement_layer = component.placement_layer
         pos_x, pos_y = pin.position
@@ -420,6 +455,9 @@ class CfgCircuitElement(CfgBase):
         else:  # pragma no cover
             raise AttributeError(f"Unsupported pad shape {pad.shape.lower()}")
 
+        width = width * expansion
+        height = height * expansion
+
         positions = []
         if contact_type.lower() == "inline":
             if width > height:
@@ -624,7 +662,7 @@ class CfgProbe(CfgCircuitElement):
             self.api = self.DotNet(self)
 
 
-class CfgWavePort:
+class CfgEdgePort:
     def __init__(self, pedb, **kwargs):
         self._pedb = pedb
         self.name = kwargs["name"]
@@ -650,10 +688,24 @@ class CfgWavePort:
         wave_port.horizontal_extent_factor = self.horizontal_extent_factor
         wave_port.vertical_extent_factor = self.vertical_extent_factor
         wave_port.pec_launch_width = self.pec_launch_width
-        wave_port.hfss_type = "Wave"
+        if self.type == "wave_port":
+            wave_port.hfss_type = "Wave"
+        else:
+            wave_port.hfss_type = "Gap"
         wave_port.do_renormalize = True
         return wave_port
 
+    def export_properties(self):
+        return {
+            "name": self.name,
+            "type": self.type,
+            "primitive_name": self.primitive_name,
+            "point_on_edge": self.point_on_edge,
+            "horizontal_extent_factor": self.horizontal_extent_factor,
+            "vertical_extent_factor": self.vertical_extent_factor,
+            "pec_launch_width": self.pec_launch_width,
+        }
+
 
 class CfgDiffWavePort:
     def __init__(self, pedb, **kwargs):
@@ -666,7 +718,7 @@ class CfgDiffWavePort:
 
         kwargs["positive_terminal"]["type"] = "wave_port"
         kwargs["positive_terminal"]["name"] = self.name + ":T1"
-        self.positive_port = CfgWavePort(
+        self.positive_port = CfgEdgePort(
             self._pedb,
             horizontal_extent_factor=self.horizontal_extent_factor,
             vertical_extent_factor=self.vertical_extent_factor,
@@ -675,7 +727,7 @@ class CfgDiffWavePort:
         )
         kwargs["negative_terminal"]["type"] = "wave_port"
         kwargs["negative_terminal"]["name"] = self.name + ":T2"
-        self.negative_port = CfgWavePort(
+        self.negative_port = CfgEdgePort(
             self._pedb,
             horizontal_extent_factor=self.horizontal_extent_factor,
             vertical_extent_factor=self.vertical_extent_factor,

pyedb/configuration/cfg_stackup.py

@@ -20,6 +20,7 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
+from pyedb import Edb
 from pyedb.configuration.cfg_common import CfgBase
 
 
@@ -49,12 +50,32 @@ class CfgLayer(CfgBase):
 
 
 class CfgStackup:
-    def __init__(self, pedb, data):
+    def __init__(self, pedb: Edb, data):
         self._pedb = pedb
 
         self.materials = [CfgMaterial(**mat) for mat in data.get("materials", [])]
         self.layers = [CfgLayer(**lay) for lay in data.get("layers", [])]
 
+        materials = [m.name for m in self.materials]
+        for i in self.layers:
+            if i.type == "signal":
+                if i.material not in materials:
+                    self.materials.append(
+                        CfgMaterial(name=i.material, **self._pedb.materials.default_conductor_property_values)
+                    )
+                    materials.append(i.material)
+                if i.fill_material not in materials:
+                    self.materials.append(
+                        CfgMaterial(name=i.fill_material, **self._pedb.materials.default_dielectric_property_values)
+                    )
+                    materials.append(i.fill_material)
+            elif i.type == "dielectric":
+                if i.material not in materials:
+                    self.materials.append(
+                        CfgMaterial(name=i.material, **self._pedb.materials.default_dielectric_property_values)
+                    )
+                    materials.append(i.material)
+
     def apply(self):
         """Apply configuration settings to the current design"""
         if len(self.materials):

pyedb/dotnet/database/cell/terminal/edge_terminal.py

@@ -48,3 +48,58 @@ class EdgeTerminal(Terminal):
         edb_list = convert_py_list_to_net_list(temp, self._edb.cell.terminal.Terminal)
         _edb_bundle_terminal = self._edb.cell.terminal.BundleTerminal.Create(edb_list)
         return self._pedb.ports[_edb_bundle_terminal.GetName()]
+
+    @property
+    def horizontal_extent_factor(self):
+        """Horizontal extent factor."""
+        return self._hfss_port_property["Horizontal Extent Factor"]
+
+    @horizontal_extent_factor.setter
+    def horizontal_extent_factor(self, value):
+        p = self._hfss_port_property
+        p["Horizontal Extent Factor"] = value
+        self._hfss_port_property = p
+
+    @property
+    def vertical_extent_factor(self):
+        """Vertical extent factor."""
+        return self._hfss_port_property["Vertical Extent Factor"]
+
+    @vertical_extent_factor.setter
+    def vertical_extent_factor(self, value):
+        p = self._hfss_port_property
+        p["Vertical Extent Factor"] = value
+        self._hfss_port_property = p
+
+    @property
+    def pec_launch_width(self):
+        """Launch width for the printed electronic component (PEC)."""
+        return self._hfss_port_property["PEC Launch Width"]
+
+    @pec_launch_width.setter
+    def pec_launch_width(self, value):
+        p = self._hfss_port_property
+        p["PEC Launch Width"] = value
+        self._hfss_port_property = p
+
+    @property
+    def deembed(self):
+        """Whether deembed is active."""
+        return self._edb_object.GetPortPostProcessingProp().DoDeembed
+
+    @deembed.setter
+    def deembed(self, value):
+        p = self._edb_object.GetPortPostProcessingProp()
+        p.DoDeembed = value
+        self._edb_object.SetPortPostProcessingProp(p)
+
+    @property
+    def deembed_length(self):
+        """Deembed Length."""
+        return self._edb_object.GetPortPostProcessingProp().DeembedLength.ToDouble()
+
+    @deembed_length.setter
+    def deembed_length(self, value):
+        p = self._edb_object.GetPortPostProcessingProp()
+        p.DeembedLength = self._pedb.edb_value(value)
+        self._edb_object.SetPortPostProcessingProp(p)

pyedb/dotnet/database/components.py

@@ -820,12 +820,13 @@ class Components(object):
         if not port_name:
             port_name = "Port_{}_{}".format(pins[0].net_name, pins[0].name)
 
-        if len(pins) > 1 > 1 or pingroup_on_single_pin:
-            pec_boundary = False
-            self._logger.info(
-                "Disabling PEC boundary creation, this feature is supported on single pin "
-                f"ports only, {len(pins)} pins found (pingroup_on_single_pin: {pingroup_on_single_pin})."
-            )
+        if len(pins) > 1 or pingroup_on_single_pin:
+            if pec_boundary:
+                pec_boundary = False
+                self._logger.info(
+                    "Disabling PEC boundary creation, this feature is supported on single pin "
+                    f"ports only, {len(pins)} pins found (pingroup_on_single_pin: {pingroup_on_single_pin})."
+                )
             group_name = "group_{}".format(port_name)
             pin_group = self.create_pingroup_from_pins(pins, group_name)
             term = self._create_pin_group_terminal(pingroup=pin_group, term_name=port_name)
@@ -834,12 +835,13 @@ class Components(object):
         term.SetIsCircuitPort(True)
 
         if len(reference_pins) > 1 or pingroup_on_single_pin:
-            pec_boundary = False
-            self._logger.info(
-                "Disabling PEC boundary creation. This feature is supported on single pin "
-                f"ports only, {len(reference_pins)} reference pins found "
-                f"(pingroup_on_single_pin: {pingroup_on_single_pin})."
-            )
+            if pec_boundary:
+                pec_boundary = False
+                self._logger.info(
+                    "Disabling PEC boundary creation. This feature is supported on single pin "
+                    f"ports only, {len(reference_pins)} reference pins found "
+                    f"(pingroup_on_single_pin: {pingroup_on_single_pin})."
+                )
             ref_group_name = "group_{}_ref".format(port_name)
             ref_pin_group = self.create_pingroup_from_pins(reference_pins, ref_group_name)
             ref_term = self._create_pin_group_terminal(pingroup=ref_pin_group, term_name=port_name + "_ref")

pyedb/dotnet/database/edb_data/padstacks_data.py

@@ -510,7 +510,7 @@ class EDBPadstack(object):
         list
             List of layers.
         """
-        return self._padstack_def_data.GetLayerNames()
+        return list(self._padstack_def_data.GetLayerNames())
 
     @property
     def via_start_layer(self):
@@ -521,7 +521,7 @@ class EDBPadstack(object):
         str
             Name of the starting layer.
         """
-        return list(self.via_layers)[0]
+        return self.via_layers[0]
 
     @property
     def via_stop_layer(self):
@@ -532,7 +532,7 @@ class EDBPadstack(object):
         str
             Name of the stopping layer.
         """
-        return list(self.via_layers)[-1]
+        return self.via_layers[-1]
 
     @property
     def hole_params(self):
@@ -2141,3 +2141,80 @@ class EDBPadstackInstance(Primitive):
             max_limit=max_limit,
             component_only=component_only,
         )
+
+    def split(self):
+        """Split padstack instance into multiple instances. The new instances only connect adjacent layers."""
+        pdef_name = self.padstack_definition
+        position = self.position
+        net_name = self.net_name
+        name = self.name
+        stackup_layer_range = list(self._pedb.stackup.signal_layers.keys())
+        start_idx = stackup_layer_range.index(self.start_layer)
+        stop_idx = stackup_layer_range.index(self.stop_layer)
+        for idx, (l1, l2) in enumerate(
+            list(zip(stackup_layer_range[start_idx:stop_idx], stackup_layer_range[start_idx + 1 : stop_idx + 1]))
+        ):
+            self._pedb.padstacks.place(position, pdef_name, net_name, f"{name}_{idx}", fromlayer=l1, tolayer=l2)
+        self.delete()
+
+    def convert_hole_to_conical_shape(self, angle=75):
+        """Convert actual padstack instance to microvias 3D Objects with a given aspect ratio.
+
+        Parameters
+        ----------
+        angle : float, optional
+            Angle of laser penetration in degrees. The angle defines the lowest hole diameter with this formula:
+            HoleDiameter -2*tan(laser_angle* Hole depth). Hole depth is the height of the via (dielectric thickness).
+            The default is ``75``.
+            The lowest hole is ``0.75*HoleDepth/HoleDiam``.
+
+        Returns
+        -------
+        """
+        pos = self.position
+        stackup_layers = self._pedb.stackup.stackup_layers
+        signal_layers = self._pedb.stackup.signal_layers
+        layer_idx = list(signal_layers.keys()).index(self.start_layer)
+
+        _layer_idx = list(stackup_layers.keys()).index(self.start_layer)
+        diel_layer_idx = list(stackup_layers.keys())[_layer_idx + 1]
+        diel_thickness = stackup_layers[diel_layer_idx].thickness
+
+        rad_large = self.definition.hole_diameter / 2
+        rad_small = rad_large - diel_thickness * 1 / math.tan(math.radians(angle))
+
+        if layer_idx + 1 < len(signal_layers) / 2:  # upper half of stack
+            rad_u = rad_large
+            rad_l = rad_small
+        else:
+            rad_u = rad_small
+            rad_l = rad_large
+
+        layout = self._pedb.active_layout
+        cloned_circle = self._edb.cell.primitive.circle.create(
+            layout,
+            self.start_layer,
+            self._edb_padstackinstance.GetNet(),
+            self._pedb.edb_value(pos[0]),
+            self._pedb.edb_value(pos[1]),
+            self._pedb.edb_value(rad_u),
+        )
+        cloned_circle2 = self._edb.cell.primitive.circle.create(
+            layout,
+            self.stop_layer,
+            self._edb_padstackinstance.GetNet(),
+            self._pedb.edb_value(pos[0]),
+            self._pedb.edb_value(pos[1]),
+            self._pedb.edb_value(rad_l),
+        )
+        s3d = self._pedb._edb.Cell.Hierarchy.Structure3D.Create(
+            layout, generate_unique_name("via3d_" + self.aedt_name.replace("via_", ""), n=3)
+        )
+        s3d.AddMember(cloned_circle.prim_obj)
+        s3d.AddMember(cloned_circle2.prim_obj)
+        s3d.SetMaterial(self.definition.material)
+        s3d.SetMeshClosureProp(self._pedb._edb.Cell.Hierarchy.Structure3D.TClosure.EndsClosed)
+
+        hole_override_enabled = True
+        hole_override_diam = 0
+        self._edb_object.SetHoleOverride(hole_override_enabled, self._pedb.edb_value(hole_override_diam))

pyedb/dotnet/database/edb_data/ports.py

@@ -117,61 +117,6 @@ class WavePort(EdgeTerminal):
     def __init__(self, pedb, edb_terminal):
         super().__init__(pedb, edb_terminal)
 
-    @property
-    def horizontal_extent_factor(self):
-        """Horizontal extent factor."""
-        return self._hfss_port_property["Horizontal Extent Factor"]
-
-    @horizontal_extent_factor.setter
-    def horizontal_extent_factor(self, value):
-        p = self._hfss_port_property
-        p["Horizontal Extent Factor"] = value
-        self._hfss_port_property = p
-
-    @property
-    def vertical_extent_factor(self):
-        """Vertical extent factor."""
-        return self._hfss_port_property["Vertical Extent Factor"]
-
-    @vertical_extent_factor.setter
-    def vertical_extent_factor(self, value):
-        p = self._hfss_port_property
-        p["Vertical Extent Factor"] = value
-        self._hfss_port_property = p
-
-    @property
-    def pec_launch_width(self):
-        """Launch width for the printed electronic component (PEC)."""
-        return self._hfss_port_property["PEC Launch Width"]
-
-    @pec_launch_width.setter
-    def pec_launch_width(self, value):
-        p = self._hfss_port_property
-        p["PEC Launch Width"] = value
-        self._hfss_port_property = p
-
-    @property
-    def deembed(self):
-        """Whether deembed is active."""
-        return self._edb_object.GetPortPostProcessingProp().DoDeembed
-
-    @deembed.setter
-    def deembed(self, value):
-        p = self._edb_object.GetPortPostProcessingProp()
-        p.DoDeembed = value
-        self._edb_object.SetPortPostProcessingProp(p)
-
-    @property
-    def deembed_length(self):
-        """Deembed Length."""
-        return self._edb_object.GetPortPostProcessingProp().DeembedLength.ToDouble()
-
-    @deembed_length.setter
-    def deembed_length(self, value):
-        p = self._edb_object.GetPortPostProcessingProp()
-        p.DeembedLength = self._pedb.edb_value(value)
-        self._edb_object.SetPortPostProcessingProp(p)
-
 
 class ExcitationSources(Terminal):
     """Manage sources properties.

pyedb/dotnet/database/materials.py

@@ -446,6 +446,33 @@ class Material(object):
 class Materials(object):
     """Manages EDB methods for material management accessible from `Edb.materials` property."""
 
+    default_conductor_property_values = {
+        "conductivity": 58000000,
+        "dielectric_loss_tangent": 0,
+        "magnetic_loss_tangent": 0,
+        "mass_density": 8933,
+        "permittivity": 1,
+        "permeability": 0.999991,
+        "poisson_ratio": 0.38,
+        "specific_heat": 385,
+        "thermal_conductivity": 400,
+        "youngs_modulus": 120000000000,
+        "thermal_expansion_coefficient": 1.77e-05,
+    }
+    default_dielectric_property_values = {
+        "conductivity": 0,
+        "dielectric_loss_tangent": 0.02,
+        "magnetic_loss_tangent": 0,
+        "mass_density": 1900,
+        "permittivity": 4.4,
+        "permeability": 1,
+        "poisson_ratio": 0.28,
+        "specific_heat": 1150,
+        "thermal_conductivity": 0.294,
+        "youngs_modulus": 11000000000,
+        "thermal_expansion_coefficient": 1.5e-05,
+    }
+
     def __init__(self, edb: Edb):
         self.__edb = edb
         self.__edb_definition = edb.edb_api.definition
@@ -520,14 +547,14 @@ class Materials(object):
 
         return material
 
-    def add_conductor_material(self, name, conductivity, **kwargs):
+    def add_conductor_material(self, name, conductivity=58000000, **kwargs):
         """Add a new conductor material.
 
         Parameters
         ----------
         name : str
             Name of the new material.
-        conductivity : str, float, int
+        conductivity : str, float, int, optional
             Conductivity of the new material.
 
         Returns
@@ -535,10 +562,11 @@ class Materials(object):
         :class:`pyedb.dotnet.database.materials.Material`
 
         """
+        props = self.default_conductor_property_values.copy()
+        props["conductivity"] = conductivity
         extended_kwargs = {key: value for (key, value) in kwargs.items()}
-        extended_kwargs["conductivity"] = conductivity
-        material = self.add_material(name, **extended_kwargs)
-
+        props.update(extended_kwargs)
+        material = self.add_material(name, **props)
         return material
 
     def add_dielectric_material(self, name, permittivity, dielectric_loss_tangent, **kwargs):
@@ -548,20 +576,21 @@ class Materials(object):
         ----------
         name : str
             Name of the new material.
-        permittivity : str, float, int
+        permittivity : str, float, int, optional
             Permittivity of the new material.
-        dielectric_loss_tangent : str, float, int
+        dielectric_loss_tangent : str, float, int, optional
             Dielectric loss tangent of the new material.
 
         Returns
         -------
         :class:`pyedb.dotnet.database.materials.Material`
         """
+        props = self.default_dielectric_property_values.copy()
+        props["permittivity"] = permittivity
+        props["dielectric_loss_tangent"] = dielectric_loss_tangent
         extended_kwargs = {key: value for (key, value) in kwargs.items()}
-        extended_kwargs["permittivity"] = permittivity
-        extended_kwargs["dielectric_loss_tangent"] = dielectric_loss_tangent
-        material = self.add_material(name, **extended_kwargs)
-
+        props.update(extended_kwargs)
+        material = self.add_material(name, **props)
         return material
 
     def add_djordjevicsarkar_dielectric(