pyedb 0.27.0__py3-none-any.whl → 0.29.0__py3-none-any.whl

pyedb/configuration/cfg_ports_sources.py

@@ -337,13 +337,15 @@ class CfgPort(CfgCircuitElement):
         return circuit_elements
 
     def export_properties(self):
-        return {
+        data = {
             "name": self.name,
             "type": self.type,
             "reference_designator": self.reference_designator,
             "positive_terminal": self.positive_terminal_info.export_properties(),
-            "negative_terminal": self.negative_terminal_info.export_properties(),
         }
+        if self.negative_terminal_info:
+            data.update({"negative_terminal": self.negative_terminal_info.export_properties()})
+        return data
 
 
 class CfgSource(CfgCircuitElement):

pyedb/configuration/cfg_s_parameter_models.py

@@ -24,37 +24,93 @@ from pathlib import Path
 
 
 class CfgSParameterModel:
-    def __init__(self, pdata, path_lib, sparam_dict):
-        self._pedb = pdata._pedb
+    def __init__(self, **kwargs):
+        self.name = kwargs.get("name", "")
+        self.component_definition = kwargs.get("component_definition", "")
+        self.file_path = kwargs.get("file_path", "")
+        self.apply_to_all = kwargs.get("apply_to_all", False)
+        self.components = kwargs.get("components", [])
+        self.reference_net = kwargs.get("reference_net", "")
+        self.reference_net_per_component = kwargs.get("reference_net_per_component", {})
+        self.pin_order = kwargs.get("pin_order", None)
+
+
+class CfgSParameters:
+    def __init__(self, pedb, data, path_lib=None):
+        self._pedb = pedb
         self.path_libraries = path_lib
-        self._sparam_dict = sparam_dict
-        self.name = self._sparam_dict.get("name", "")
-        self.component_definition = self._sparam_dict.get("component_definition", "")
-        self.file_path = self._sparam_dict.get("file_path", "")
-        self.apply_to_all = self._sparam_dict.get("apply_to_all", False)
-        self.components = self._sparam_dict.get("components", [])
-        self.reference_net = self._sparam_dict.get("reference_net", "")
-        self.reference_net_per_component = self._sparam_dict.get("reference_net_per_component", {})
+        self.s_parameters_models = [CfgSParameterModel(**i) for i in data]
 
     def apply(self):
-        fpath = self.file_path
-        if not Path(fpath).anchor:
-            fpath = str(Path(self.path_libraries) / fpath)
-        comp_def = self._pedb.definitions.component[self.component_definition]
-        comp_def.add_n_port_model(fpath, self.name)
-        comp_list = dict()
-        if self.apply_to_all:
-            comp_list.update(
-                {refdes: comp for refdes, comp in comp_def.components.items() if refdes not in self.components}
-            )
-        else:
-            comp_list.update(
-                {refdes: comp for refdes, comp in comp_def.components.items() if refdes in self.components}
-            )
+        for s_param in self.s_parameters_models:
+            fpath = s_param.file_path
+            if not Path(fpath).anchor:
+                fpath = str(Path(self.path_libraries) / fpath)
+            comp_def = self._pedb.definitions.component[s_param.component_definition]
+            if s_param.pin_order:
+                comp_def.set_properties(pin_order=s_param.pin_order)
+            comp_def.add_n_port_model(fpath, s_param.name)
+            comp_list = dict()
+            if s_param.apply_to_all:
+                comp_list.update(
+                    {refdes: comp for refdes, comp in comp_def.components.items() if refdes not in s_param.components}
+                )
+            else:
+                comp_list.update(
+                    {refdes: comp for refdes, comp in comp_def.components.items() if refdes in s_param.components}
+                )
 
-        for refdes, comp in comp_list.items():
-            if refdes in self.reference_net_per_component:
-                ref_net = self.reference_net_per_component[refdes]
+            for refdes, comp in comp_list.items():
+                if refdes in s_param.reference_net_per_component:
+                    ref_net = s_param.reference_net_per_component[refdes]
+                else:
+                    ref_net = s_param.reference_net
+                comp.use_s_parameter_model(s_param.name, reference_net=ref_net)
+
+    def get_data_from_db(self):
+        db_comp_def = self._pedb.definitions.component
+        for name, compdef_obj in db_comp_def.items():
+            nport_models = compdef_obj.component_models
+            if not nport_models:
+                continue
             else:
-                ref_net = self.reference_net
-            comp.use_s_parameter_model(self.name, reference_net=ref_net)
+                pin_order = compdef_obj.get_properties()["pin_order"]
+                temp_comps = compdef_obj.components
+                for model_name, model_obj in nport_models.items():
+                    temp_comp_list = []
+                    reference_net_per_component = {}
+                    for i in temp_comps.values():
+                        s_param_model = i.model_properties.get("s_parameter_model")
+                        if s_param_model:
+                            if s_param_model["model_name"] == model_name:
+                                temp_comp_list.append(i.refdes)
+                                reference_net_per_component[i.refdes] = s_param_model["reference_net"]
+                        else:
+                            continue
+
+                    self.s_parameters_models.append(
+                        CfgSParameterModel(
+                            name=model_name,
+                            component_definition=name,
+                            file_path=model_obj.reference_file,
+                            apply_to_all=False,
+                            components=temp_comp_list,
+                            reference_net_per_component=reference_net_per_component,
+                            pin_order=pin_order,
+                        )
+                    )
+
+        data = []
+        for i in self.s_parameters_models:
+            data.append(
+                {
+                    "name": i.name,
+                    "component_definition": i.component_definition,
+                    "file_path": i.file_path,
+                    "apply_to_all": i.apply_to_all,
+                    "components": i.components,
+                    "reference_net_per_component": i.reference_net_per_component,
+                    "pin_order": i.pin_order,
+                }
+            )
+        return data

pyedb/configuration/configuration.py

@@ -74,7 +74,7 @@ class Configuration:
                     elif config_file.endswith(".toml"):
                         data = toml.load(f)
             else:  # pragma: no cover
-                return False
+                raise RuntimeError(f"File {config_file} does not exist.")
 
         if not append:  # pragma: no cover
             self.data = {}
@@ -103,7 +103,7 @@ class Configuration:
                 self._pedb.open_edb()
         return self.cfg_data
 
-    def run(self):
+    def run(self, **kwargs):
         """Apply configuration settings to the current design"""
 
         # Configure boundary settings
@@ -117,10 +117,6 @@ class Configuration:
         # Configure components
         self.cfg_data.components.apply()
 
-        # Configure padstacks
-        if self.cfg_data.padstacks:
-            self.cfg_data.padstacks.apply()
-
         # Configure pin groups
         self.cfg_data.pin_groups.apply()
 
@@ -134,11 +130,23 @@ class Configuration:
         self.cfg_data.setups.apply()
 
         # Configure stackup
-        self.cfg_data.stackup.apply()
+        if kwargs.get("fix_padstack_def"):
+            pedb_defs = self._pedb.padstacks.definitions
+            temp = {}
+            for name, pdef in pedb_defs.items():
+                temp[name] = pdef.get_properties()
+            self.cfg_data.stackup.apply()
+            for name, pdef_p in temp.items():
+                pedb_defs[name].set_properties(**pdef_p)
+        else:
+            self.cfg_data.stackup.apply()
+
+        # Configure padstacks
+        if self.cfg_data.padstacks:
+            self.cfg_data.padstacks.apply()
 
         # Configure S-parameter
-        for s_parameter_model in self.cfg_data.s_parameters:
-            s_parameter_model.apply()
+        self.cfg_data.s_parameters.apply()
 
         # Configure SPICE models
         for spice_model in self.cfg_data.spice_models:
@@ -282,6 +290,12 @@ class Configuration:
             data["pin_groups"] = self.cfg_data.pin_groups.get_data_from_db()
         if kwargs.get("operations", False):
             data["operations"] = self.cfg_data.operations.get_data_from_db()
+        if kwargs.get("padstacks", False):
+            data["padstacks"] = self.cfg_data.padstacks.get_data_from_db()
+        if kwargs.get("s_parameters", False):
+            data["s_parameters"] = self.cfg_data.s_parameters.get_data_from_db()
+        if kwargs.get("boundaries", False):
+            data["boundaries"] = self.cfg_data.boundaries.get_data_from_db()
 
         return data
 
@@ -296,6 +310,10 @@ class Configuration:
         nets=True,
         pin_groups=True,
         operations=True,
+        components=True,
+        boundaries=True,
+        s_parameters=True,
+        padstacks=True,
     ):
         """Export the configuration data from layout to a file.
 
@@ -319,22 +337,39 @@ class Configuration:
             Whether to export pin groups.
         operations : bool
             Whether to export operations.
+        components : bool
+            Whether to export component.
+        boundaries : bool
+            Whether to export boundaries.
+        s_parameters : bool
+            Whether to export s_parameters.
+        padstacks : bool
+            Whether to export padstacks.
         Returns
         -------
         bool
         """
-        file_path = file_path if isinstance(file_path, Path) else Path(file_path)
-        file_path = file_path if file_path.suffix == ".json" else file_path.with_suffix(".json")
         data = self.get_data_from_db(
             stackup=stackup,
             package_definitions=package_definitions,
-            setups=setups,
+            setups=False,
             sources=sources,
             ports=ports,
             nets=nets,
             pin_groups=pin_groups,
             operations=operations,
+            components=components,
+            boundaries=boundaries,
+            s_parameters=s_parameters,
+            padstacks=padstacks,
         )
+
+        file_path = file_path if isinstance(file_path, Path) else Path(file_path)
+        file_path = file_path.with_suffix(".json") if file_path.suffix == "" else file_path
+
         with open(file_path, "w") as f:
-            json.dump(data, f, ensure_ascii=False, indent=4)
+            if file_path.suffix == ".json":
+                json.dump(data, f, ensure_ascii=False, indent=4)
+            else:
+                toml.dump(data, f)
         return True if os.path.isfile(file_path) else False

pyedb/dotnet/application/Variables.py

@@ -27,7 +27,7 @@ This module is used to create and edit design and project variables in the 3D to
 
 Examples
 --------
->>> from pyaedt import Hfss
+>>> from ansys.aedt.core import Hfss
 >>> hfss = Hfss()
 >>> hfss["$d"] = "5mm"
 >>> hfss["d"] = "5mm"
@@ -415,8 +415,8 @@ class VariableManager(object):
     Examples
     --------
 
-    >>> from pyaedt.maxwell import Maxwell3d
-    >>> from pyaedt.desktop import Desktop
+    >>> from ansys.aedt.core.maxwell import Maxwell3d
+    >>> from ansys.aedt.core.desktop import Desktop
     >>> d = Desktop()
     >>> aedtapp = Maxwell3d()
 
@@ -1765,40 +1765,42 @@ class Variable(object):
     def __mul__(self, other):  # pragma: no cover
         """Multiply the variable with a number or another variable and return a new object.
 
-                Parameters
-                ----------
-                other : numbers.Number or variable
-                    Object to be multiplied.
-
-                Returns
-                -------
-                type
-                    Variable.
-
-                Examples
-                --------
-                >>> from pyedb.dotnet.application.Variables import Variable
-
-                Multiply ``'Length1'`` by unitless ``'None'``` to obtain ``'Length'``.
-                A numerical value is also considered to be unitless.
-
-        import pyaedt.generic.constants        >>> v1 = Variable("10mm")
-                >>> v2 = Variable(3)
-                >>> result_1 = v1 * v2
-                >>> result_2 = v1 * 3
-                >>> assert result_1.numeric_value == 30.0
-                >>> assert result_1.unit_system == "Length"
-                >>> assert result_2.numeric_value == result_1.numeric_value
-                >>> assert result_2.unit_system == "Length"
-
-                Multiply voltage times current to obtain power.
-
-        import pyaedt.generic.constants        >>> v3 = Variable("3mA")
-                >>> v4 = Variable("40V")
-                >>> result_3 = v3 * v4
-                >>> assert result_3.numeric_value == 0.12
-                >>> assert result_3.units == "W"
-                >>> assert result_3.unit_system == "Power"
+        Parameters
+        ----------
+        other : numbers.Number or variable
+            Object to be multiplied.
+
+        Returns
+        -------
+        type
+            Variable.
+
+        Examples
+        --------
+        >>> from pyedb.dotnet.application.Variables import Variable
+
+        Multiply ``'Length1'`` by unitless ``'None'``` to obtain ``'Length'``.
+        A numerical value is also considered to be unitless.
+
+        >>> import ansys.aedt.core.generic.constants
+        >>> v1 = Variable("10mm")
+        >>> v2 = Variable(3)
+        >>> result_1 = v1 * v2
+        >>> result_2 = v1 * 3
+        >>> assert result_1.numeric_value == 30.0
+        >>> assert result_1.unit_system == "Length"
+        >>> assert result_2.numeric_value == result_1.numeric_value
+        >>> assert result_2.unit_system == "Length"
+
+        Multiply voltage times current to obtain power.
+
+        >>> import ansys.aedt.core.generic.constants
+        >>> v3 = Variable("3mA")
+        >>> v4 = Variable("40V")
+        >>> result_3 = v3 * v4
+        >>> assert result_3.numeric_value == 0.12
+        >>> assert result_3.units == "W"
+        >>> assert result_3.unit_system == "Power"
 
         """
         assert is_number(other) or isinstance(other, Variable), "Multiplier must be a scalar quantity or a variable."
@@ -1836,7 +1838,7 @@ class Variable(object):
         Examples
         --------
         >>> from pyedb.dotnet.application.Variables import Variable
-        >>> import pyaedt.generic.constants
+        >>> import ansys.aedt.core.generic.constants
         >>> v1 = Variable("3mA")
         >>> v2 = Variable("10A")
         >>> result = v1 + v2
@@ -1876,7 +1878,7 @@ class Variable(object):
         Examples
         --------
 
-        >>> import pyaedt.generic.constants
+        >>> import ansys.aedt.core.generic.constants
         >>> from pyedb.dotnet.application.Variables import Variable
         >>> v3 = Variable("3mA")
         >>> v4 = Variable("10A")
@@ -1922,7 +1924,7 @@ class Variable(object):
         resolve the new units to ``"A"``.
 
         >>> from pyedb.dotnet.application.Variables import Variable
-        >>> import pyaedt.generic.constants
+        >>> import ansys.aedt.core.generic.constants
         >>> v1 = Variable("10W")
         >>> v2 = Variable("40V")
         >>> result = v1 / v2
@@ -1964,7 +1966,7 @@ class Variable(object):
         Divide a number by a variable with units ``"s"`` and automatically determine that
         the result is in ``"Hz"``.
 
-        >>> import pyaedt.generic.constants
+        >>> import ansys.aedt.core.generic.constants
         >>> from pyedb.dotnet.application.Variables import Variable
         >>> v = Variable("1s")
         >>> result = 3.0 / v

pyedb/dotnet/edb.py

@@ -1630,6 +1630,14 @@ class Edb(Database):
                     )
                 else:
                     obj_data = i.Expand(expansion_size, tolerance, round_corner, round_extension)
+                if inlcude_voids_in_extents and "PolygonData" not in str(i) and i.has_voids and obj_data:
+                    for void in i.voids:
+                        void_data = void.primitive_object.GetPolygonData().Expand(
+                            -1 * expansion_size, tolerance, round_corner, round_extension
+                        )
+                        if void_data:
+                            for v in list(void_data):
+                                obj_data[0].AddHole(v)
                 if obj_data:
                     if not inlcude_voids_in_extents:
                         unite_polys.extend(list(obj_data))
@@ -2209,9 +2217,9 @@ class Edb(Database):
                     pins_to_preserve.extend([i.id for i in el.pins.values()])
                     nets_to_preserve.extend(el.nets)
         if include_pingroups:
-            for reference in reference_list:
-                for pin in self.nets.nets[reference].padstack_instances:
-                    if pin.pingroups:
+            for pingroup in self.padstacks.pingroups:
+                for pin in pingroup.pins.values():
+                    if pin.net_name in reference_list:
                         pins_to_preserve.append(pin.id)
         if check_terminals:
             terms = [
@@ -2280,12 +2288,12 @@ class Edb(Database):
             if extent_type in ["Conforming", self.edb_api.geometry.extent_type.Conforming, 1]:
                 if extent_defeature > 0:
                     _poly = _poly.Defeature(extent_defeature)
-
                 _poly1 = _poly.CreateFromArcs(_poly.GetArcData(), True)
                 if inlcude_voids_in_extents:
                     for hole in list(_poly.Holes):
                         if hole.Area() >= 0.05 * _poly1.Area():
                             _poly1.AddHole(hole)
+                    self.logger.info(f"Number of voids included:{len(list(_poly1.Holes))}")
                 _poly = _poly1
         if not _poly or _poly.IsNull():
             self._logger.error("Failed to create Extent.")

pyedb/dotnet/edb_core/cell/hierarchy/component.py

@@ -33,6 +33,7 @@ from pyedb.dotnet.edb_core.cell.hierarchy.s_parameter_model import SparamModel
 from pyedb.dotnet.edb_core.cell.hierarchy.spice_model import SpiceModel
 from pyedb.dotnet.edb_core.definition.package_def import PackageDef
 from pyedb.dotnet.edb_core.edb_data.padstacks_data import EDBPadstackInstance
+from pyedb.dotnet.edb_core.general import pascal_to_snake, snake_to_pascal
 
 try:
     import numpy as np
@@ -1008,3 +1009,201 @@ class EDBComponent(Group):
         )
         void.is_negative = True
         return True
+
+    @property
+    def model_properties(self):
+        pp = {}
+        c_p = self.component_property
+        model = c_p.GetModel().Clone()
+        netlist_model = {}
+        pin_pair_model = []
+        s_parameter_model = {}
+        spice_model = {}
+        if model.GetModelType().ToString() == "NetlistModel":
+            netlist_model["netlist"] = model.GetNetlist()
+        elif model.GetModelType().ToString() == "PinPairModel":
+            temp = {}
+            for i in model.PinPairs:
+                temp["first_pin"] = i.FirstPin
+                temp["second_pin"] = i.SecondPin
+                rlc = model.GetPinPairRlc(i)
+                temp["is_parallel"] = rlc.IsParallel
+                temp["resistance"] = rlc.R.ToString()
+                temp["resistance_enabled"] = rlc.REnabled
+                temp["inductance"] = rlc.L.ToString()
+                temp["inductance_enabled"] = rlc.LEnabled
+                temp["capacitance"] = rlc.C.ToString()
+                temp["capacitance_enabled"] = rlc.CEnabled
+                pin_pair_model.append(temp)
+        elif model.GetModelType().ToString() == "SParameterModel":
+            s_parameter_model["reference_net"] = model.GetReferenceNet()
+            s_parameter_model["model_name"] = model.GetComponentModelName()
+        elif model.GetModelType().ToString() == "SPICEModel":
+            spice_model["model_name"] = model.GetModelName()
+            spice_model["model_path"] = model.GetModelPath()
+            spice_model["sub_circuit"] = model.GetSubCkt()
+            spice_model["terminal_pairs"] = [[i, j] for i, j in dict(model.GetTerminalPinPairs()).items()]
+
+        if netlist_model:
+            pp["netlist_model"] = netlist_model
+        if pin_pair_model:
+            pp["pin_pair_model"] = pin_pair_model
+        if s_parameter_model:
+            pp["s_parameter_model"] = s_parameter_model
+        if spice_model:
+            pp["spice_model"] = spice_model
+        return pp
+
+    @model_properties.setter
+    def model_properties(self, kwargs):
+        netlist_model = kwargs.get("netlist_model")
+        pin_pair_model = kwargs.get("pin_pair_model")
+        s_parameter_model = kwargs.get("s_parameter_model")
+        spice_model = kwargs.get("spice_model")
+
+        c_p = self.component_property
+        if netlist_model:
+            m = self._pedb._edb.Cell.Hierarchy.SParameterModel()
+            m.SetNetlist(netlist_model["netlist"])
+            c_p.SetModel(m)
+            self.component_property = c_p
+        elif pin_pair_model:
+            m = self._pedb._edb.Cell.Hierarchy.PinPairModel()
+            for i in pin_pair_model:
+                p = self._pedb._edb.Utility.PinPair(str(i["first_pin"]), str(i["second_pin"]))
+                rlc = self._pedb._edb.Utility.Rlc(
+                    self._pedb.edb_value(i["resistance"]),
+                    i["resistance_enabled"],
+                    self._pedb.edb_value(i["inductance"]),
+                    i["inductance_enabled"],
+                    self._pedb.edb_value(i["capacitance"]),
+                    i["capacitance_enabled"],
+                    i["is_parallel"],
+                )
+                m.SetPinPairRlc(p, rlc)
+            c_p.SetModel(m)
+            self.component_property = c_p
+        elif s_parameter_model:
+            m = self._pedb._edb.Cell.Hierarchy.SParameterModel()
+            m.SetComponentModelName(s_parameter_model["model_name"])
+            m.SetReferenceNet(s_parameter_model["reference_net"])
+            c_p.SetModel(m)
+            self.component_property = c_p
+        elif spice_model:
+            self.assign_spice_model(
+                spice_model["model_path"],
+                spice_model["model_name"],
+                spice_model["sub_circuit"],
+                spice_model["terminal_pairs"],
+            )
+
+    @property
+    def ic_die_properties(self):
+        temp = dict()
+        cp = self.component_property
+        c_type = self.type.lower()
+        if not c_type == "ic":
+            return temp
+        else:
+            ic_die_prop = cp.GetDieProperty().Clone()
+            die_type = pascal_to_snake(ic_die_prop.GetType().ToString())
+            temp["type"] = die_type
+            if not die_type == "no_die":
+                temp["orientation"] = pascal_to_snake(ic_die_prop.GetOrientation())
+                if die_type == "wire_bond":
+                    temp["height"] = ic_die_prop.GetHeightValue().ToString()
+            return temp
+
+    @ic_die_properties.setter
+    def ic_die_properties(self, kwargs):
+        cp = self.component_property
+        c_type = self.type.lower()
+        if not c_type == "ic":
+            return
+        else:
+            ic_die_prop = cp.GetDieProperty().Clone()
+            die_type = kwargs.get("type")
+            if not die_type == "no_die":
+                orientation = kwargs.get("orientation")
+                if orientation:
+                    ic_die_prop.SetOrientation(getattr(self._edb.definition.DieType, snake_to_pascal(die_type)))
+                if die_type == "wire_bond":
+                    height = kwargs.get("height")
+                    if height:
+                        ic_die_prop.SetHeight(self._pedb.edb_value(height))
+            cp.SetDieProperty(ic_die_prop)
+            self.component_property = cp
+
+    @property
+    def solder_ball_properties(self):
+        temp = dict()
+        cp = self.component_property
+        c_type = self.type.lower()
+        if c_type not in ["io", "other"]:
+            return temp
+        else:
+            solder_ball_prop = cp.GetSolderBallProperty().Clone()
+            _, diam, mid_diam = solder_ball_prop.GetDiameterValue()
+            height = solder_ball_prop.GetHeightValue().ToString()
+            shape = solder_ball_prop.GetShape().ToString()
+            uses_solder_ball = solder_ball_prop.UsesSolderball()
+            temp["uses_solder_ball"] = uses_solder_ball
+            temp["shape"] = pascal_to_snake(shape)
+            temp["diameter"] = diam.ToString()
+            temp["mid_diameter"] = mid_diam.ToString()
+            temp["height"] = height
+            return temp
+
+    @solder_ball_properties.setter
+    def solder_ball_properties(self, kwargs):
+        cp = self.component_property
+        solder_ball_prop = cp.GetSolderBallProperty().Clone()
+        shape = kwargs.get("shape")
+        if shape:
+            solder_ball_prop.SetShape(getattr(self._edb.definition.SolderballShape, snake_to_pascal(shape)))
+        if shape == "cylinder":
+            diameter = kwargs["diameter"]
+            solder_ball_prop.SetDiameter(self._pedb.edb_value(diameter), self._pedb.edb_value(diameter))
+        elif shape == "spheroid":
+            diameter = kwargs["diameter"]
+            mid_diameter = kwargs["mid_diameter"]
+            solder_ball_prop.SetDiameter(self._pedb.edb_value(diameter), self._pedb.edb_value(mid_diameter))
+        else:
+            return
+        solder_ball_prop.SetHeight(self._get_edb_value(kwargs["height"]))
+        cp.SetSolderBallProperty(solder_ball_prop)
+        self.component_property = cp
+
+    @property
+    def port_properties(self):
+        temp = dict()
+        cp = self.component_property
+        c_type = self.type.lower()
+        if c_type not in ["ic", "io", "other"]:
+            return temp
+        else:
+            port_prop = cp.GetPortProperty().Clone()
+            reference_height = port_prop.GetReferenceHeightValue().ToString()
+            reference_size_auto = port_prop.GetReferenceSizeAuto()
+            _, reference_size_x, reference_size_y = port_prop.GetReferenceSize()
+            temp["reference_height"] = reference_height
+            temp["reference_size_auto"] = reference_size_auto
+            temp["reference_size_x"] = str(reference_size_x)
+            temp["reference_size_y"] = str(reference_size_y)
+            return temp
+
+    @port_properties.setter
+    def port_properties(self, kwargs):
+        cp = self.component_property
+        port_prop = cp.GetPortProperty().Clone()
+        height = kwargs.get("reference_height")
+        if height:
+            port_prop.SetReferenceHeight(self._pedb.edb_value(height))
+        reference_size_auto = kwargs.get("reference_size_auto")
+        if reference_size_auto:
+            port_prop.SetReferenceSizeAuto(reference_size_auto)
+        reference_size_x = kwargs.get("reference_size_x", 0)
+        reference_size_y = kwargs.get("reference_size_y", 0)
+        port_prop.SetReferenceSize(self._pedb.edb_value(reference_size_x), self._pedb.edb_value(reference_size_y))
+        cp.SetPortProperty(port_prop)
+        self.component_property = cp

pyedb/dotnet/edb_core/cell/layout.py

@@ -323,7 +323,10 @@ class Layout(ObjBase):
 
         """
         obj = self._pedb._edb.Cell.Net.FindByName(self._edb_object, value)
-        return EDBNetsData(obj, self._pedb) if obj is not None else None
+        if obj.IsNull():
+            raise ValueError(f"Net {value} doesn't exist")
+        else:
+            return EDBNetsData(obj, self._pedb)
 
     def find_component_by_name(self, value: str):
         """Find a component object by name. Component name is the reference designator in layout.

pyedb/dotnet/edb_core/cell/primitive/primitive.py

@@ -160,6 +160,8 @@ class Primitive(Connectable):
         -------
         float
         """
+        if "GetPolygonData" not in dir(self._edb_object):
+            return 0
         area = self._edb_object.GetPolygonData().Area()
         if include_voids:
             for el in self._edb_object.Voids: