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

pyedb/configuration/configuration.py

@@ -106,6 +106,9 @@ class Configuration:
     def run(self, **kwargs):
         """Apply configuration settings to the current design"""
 
+        if self.cfg_data.variables:
+            self.cfg_data.variables.apply()
+
         if self.cfg_data.general:
             self.cfg_data.general.apply()
 
@@ -123,9 +126,6 @@ class Configuration:
         # Configure pin groups
         self.cfg_data.pin_groups.apply()
 
-        # Configure ports
-        self.cfg_data.ports.apply()
-
         # Configure sources
         self.cfg_data.sources.apply()
 
@@ -161,6 +161,12 @@ class Configuration:
         # Configure operations
         self.cfg_data.operations.apply()
 
+        # Modeler
+        self.cfg_data.modeler.apply()
+
+        # Configure ports
+        self.cfg_data.ports.apply()
+
         return True
 
     def _load_stackup(self):
@@ -287,8 +293,16 @@ class Configuration:
             data["sources"] = self.cfg_data.sources.get_data_from_db()
         if kwargs.get("ports", False):
             data["ports"] = self.cfg_data.ports.get_data_from_db()
-        if kwargs.get("components", False):
-            data["components"] = self.cfg_data.components.get_data_from_db()
+        if kwargs.get("components", False) or kwargs.get("s_parameters", False):
+            self.cfg_data.components.retrieve_parameters_from_edb()
+            components = []
+            for i in self.cfg_data.components.components:
+                components.append(i.get_attributes())
+
+            if kwargs.get("components", False):
+                data["components"] = components
+            elif kwargs.get("s_parameters", False):
+                data["s_parameters"] = self.cfg_data.s_parameters.get_data_from_db(components)
         if kwargs.get("nets", False):
             data["nets"] = self.cfg_data.nets.get_data_from_db()
         if kwargs.get("pin_groups", False):
@@ -296,9 +310,17 @@ class Configuration:
         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()
+            self.cfg_data.padstacks.retrieve_parameters_from_edb()
+            definitions = []
+            for i in self.cfg_data.padstacks.definitions:
+                definitions.append(i.get_attributes())
+            instances = []
+            for i in self.cfg_data.padstacks.instances:
+                instances.append(i.get_attributes())
+            data["padstacks"] = dict()
+            data["padstacks"]["definitions"] = definitions
+            data["padstacks"]["instances"] = instances
+
         if kwargs.get("boundaries", False):
             data["boundaries"] = self.cfg_data.boundaries.get_data_from_db()
 
@@ -308,7 +330,7 @@ class Configuration:
         self,
         file_path,
         stackup=True,
-        package_definitions=True,
+        package_definitions=False,
         setups=True,
         sources=True,
         ports=True,

pyedb/dotnet/clr_module.py

@@ -1,68 +1,125 @@
 import os
+from pathlib import Path
 import pkgutil
+import shutil
 import sys
 import warnings
 
+import pyedb
+
+LINUX_WARNING = (
+    "Due to compatibility issues between .NET Core and libssl on some Linux versions, "
+    "for example Ubuntu 22.04, we are going to stop depending on `dotnetcore2`."
+    "Instead of using this package which embeds .NET Core 3, users will be required to "
+    "install .NET themselves. For more information, see "
+    "https://edb.docs.pyansys.com/version/stable/build_breaking_change.html"
+)
+
+existing_showwarning = warnings.showwarning
+
+
+def custom_show_warning(message, category, filename, lineno, file=None, line=None):
+    """Custom warning used to remove <stdin>:loc: pattern."""
+    print(f"{category.__name__}: {message}")
+
+
+warnings.showwarning = custom_show_warning
+
 modules = [tup[1] for tup in pkgutil.iter_modules()]
 cpython = "IronPython" not in sys.version and ".NETFramework" not in sys.version
 is_linux = os.name == "posix"
 is_windows = not is_linux
 is_clr = False
+pyedb_path = Path(pyedb.__file__).parent
+sys.path.append(str(pyedb_path / "dlls" / "PDFReport"))
 
-try:
-    import pyedb
 
-    pyedb_path = os.path.dirname(os.path.abspath(pyedb.__file__))
-    sys.path.append(os.path.join(pyedb_path, "dlls", "PDFReport"))
-except ImportError:
-    pyedb_path = None
-    warnings.warn("Cannot import pyedb.")
+def find_dotnet_root() -> Path:
+    """Find dotnet root path."""
+    dotnet_path = shutil.which("dotnet")
+    if not dotnet_path:
+        raise FileNotFoundError("The 'dotnet' executable was not found in the PATH.")
 
-if is_linux and cpython:  # pragma: no cover
+    dotnet_path = Path(dotnet_path).resolve()
+    dotnet_root = dotnet_path.parent
+    return dotnet_root
+
+
+def find_runtime_config(dotnet_root: Path) -> Path:
+    """Find dotnet runtime configuration file path."""
+    sdk_path = dotnet_root / "sdk"
+    if not sdk_path.is_dir():
+        raise EnvironmentError(f"The 'sdk' directory could not be found in: {dotnet_root}")
+    sdk_versions = sorted(sdk_path.iterdir(), key=lambda x: x.name, reverse=True)
+    if not sdk_versions:
+        raise FileNotFoundError("No SDK versions were found.")
+    runtime_config = sdk_versions[0] / "dotnet.runtimeconfig.json"
+    if not runtime_config.is_file():
+        raise FileNotFoundError(f"The configuration file '{runtime_config}' does not exist.")
+    return runtime_config
+
+
+if is_linux:  # pragma: no cover
+    from pythonnet import load
+
+    # Use system DOTNET core runtime
     try:
+        from clr_loader import get_coreclr
+
+        runtime = get_coreclr()
+        load(runtime)
+        is_clr = True
+    # Define DOTNET root and runtime config file to load DOTNET core runtime
+    except Exception:
         if os.environ.get("DOTNET_ROOT") is None:
-            runtime = None
             try:
-                import dotnet
+                dotnet_root = find_dotnet_root()
+                runtime_config = find_runtime_config(dotnet_root)
+            except Exception:
+                warnings.warn(
+                    "Unable to set DOTNET root and locate the runtime configuration file. "
+                    "Falling back to using dotnetcore2."
+                )
+                warnings.warn(LINUX_WARNING)
 
-                runtime = os.path.join(os.path.dirname(dotnet.__path__))
-            except:
                 import dotnetcore2
 
-                runtime = os.path.join(os.path.dirname(dotnetcore2.__file__), "bin")
-            finally:
-                os.environ["DOTNET_ROOT"] = runtime
-
-        from pythonnet import load
-
-        if pyedb_path is not None:
-            json_file = os.path.abspath(os.path.join(pyedb_path, "misc", "pyedb.runtimeconfig.json"))
-            load("coreclr", runtime_config=json_file, dotnet_root=os.environ["DOTNET_ROOT"])
-            print("DotNet Core correctly loaded.")
+                dotnet_root = Path(dotnetcore2.__file__).parent / "bin"
+                runtime_config = pyedb_path / "misc" / "pyedb.runtimeconfig.json"
+        else:
+            dotnet_root = Path(os.environ["DOTNET_ROOT"])
+            try:
+                runtime_config = find_runtime_config(dotnet_root)
+            except Exception as e:
+                raise RuntimeError(
+                    "Configuration file could not be found from DOTNET_ROOT. "
+                    "Please ensure that .NET SDK is correctly installed or "
+                    "that DOTNET_ROOT is correctly set."
+                )
+        try:
+            load("coreclr", runtime_config=str(runtime_config), dotnet_root=str(dotnet_root))
             if "mono" not in os.getenv("LD_LIBRARY_PATH", ""):
                 warnings.warn("LD_LIBRARY_PATH needs to be setup to use pyedb.")
-                warnings.warn("export ANSYSEM_ROOT232=/path/to/AnsysEM/v232/Linux64")
+                warnings.warn("export ANSYSEM_ROOT242=/path/to/AnsysEM/v242/Linux64")
                 msg = "export LD_LIBRARY_PATH="
-                msg += "$ANSYSEM_ROOT232/common/mono/Linux64/lib64:$LD_LIBRARY_PATH"
+                msg += "$ANSYSEM_ROOT242/common/mono/Linux64/lib64:$LD_LIBRARY_PATH"
                 msg += (
-                    "If PyEDB will run on AEDT<2023.2 then $ANSYSEM_ROOT222/Delcross should be added to LD_LIBRARY_PATH"
+                    "If PyEDB is used with AEDT<2023.2 then /path/to/AnsysEM/v2XY/Linux64/Delcross "
+                    "should be added to LD_LIBRARY_PATH."
                 )
                 warnings.warn(msg)
             is_clr = True
-        else:
-            print("DotNet Core not correctly loaded.")
-    except ImportError:
-        msg = "pythonnet or dotnetcore not installed. Pyedb will work only in client mode."
-        warnings.warn(msg)
+        except ImportError:
+            msg = "pythonnet or dotnetcore not installed. Pyedb will work only in client mode."
+            warnings.warn(msg)
 else:
     try:
         from pythonnet import load
 
         load("coreclr")
         is_clr = True
-
     except:
-        pass
+        warnings.warn("Unable to load DOTNET core runtime")
 
 
 try:  # work around a number formatting bug in the EDB API for non-English locales
@@ -93,6 +150,7 @@ except ImportError:  # pragma: no cover
     Dictionary = None
     Array = None
     edb_initialized = False
+
 if "win32com" in modules:
     try:
         import win32com.client as win32_client
@@ -101,3 +159,5 @@ if "win32com" in modules:
             import win32com.client as win32_client
         except ImportError:
             win32_client = None
+
+warnings.showwarning = existing_showwarning

pyedb/dotnet/edb.py

@@ -95,7 +95,7 @@ from pyedb.dotnet.edb_core.utilities.siwave_simulation_setup import (
     SiwaveDCSimulationSetup,
     SiwaveSimulationSetup,
 )
-from pyedb.generic.constants import AEDT_UNITS, SolverType
+from pyedb.generic.constants import AEDT_UNITS, SolverType, unit_converter
 from pyedb.generic.general_methods import (
     generate_unique_name,
     get_string_version,
@@ -3180,7 +3180,7 @@ class Edb(Database):
         self.logger.info("Variable %s doesn't exists.", variable_name)
         return None
 
-    def add_project_variable(self, variable_name, variable_value):
+    def add_project_variable(self, variable_name, variable_value, description=""):
         """Add a variable to edb database (project). The variable will have the prefix `$`.
 
         ..note::
@@ -3192,6 +3192,8 @@ class Edb(Database):
             Name of the variable. Name can be provided without ``$`` prefix.
         variable_value : str, float
             Value of the variable with units.
+        description : str, optional
+            Description of the variable.
 
         Returns
         -------
@@ -3210,9 +3212,11 @@ class Edb(Database):
         """
         if not variable_name.startswith("$"):
             variable_name = "${}".format(variable_name)
-        return self.add_design_variable(variable_name=variable_name, variable_value=variable_value)
+        return self.add_design_variable(
+            variable_name=variable_name, variable_value=variable_value, description=description
+        )
 
-    def add_design_variable(self, variable_name, variable_value, is_parameter=False):
+    def add_design_variable(self, variable_name, variable_value, is_parameter=False, description=""):
         """Add a variable to edb. The variable can be a design one or a project variable (using ``$`` prefix).
 
         ..note::
@@ -3228,7 +3232,8 @@ class Edb(Database):
         is_parameter : bool, optional
             Whether to add the variable as a local variable. The default is ``False``.
             When ``True``, the variable is added as a parameter default.
-
+        description : str, optional
+            Description of the variable.
         Returns
         -------
         tuple
@@ -3250,6 +3255,8 @@ class Edb(Database):
         var_server = self.variable_exists(variable_name)
         if not var_server[0]:
             var_server[1].AddVariable(variable_name, self.edb_value(variable_value), is_parameter)
+            if description:
+                var_server[1].SetVariableDescription(variable_name, description)
             return True, var_server[1]
         self.logger.error("Variable %s already exists.", variable_name)
         return False, var_server[1]
@@ -4598,3 +4605,45 @@ class Edb(Database):
     def workflow(self):
         """Workflow class."""
         return Workflow(self)
+
+    def export_gds_comp_xml(self, comps_to_export, gds_comps_unit="mm", control_path=None):
+        """Exports an XML file with selected components information for use in a GDS import.
+
+        Parameters
+        ----------
+        comps_to_export : list
+            List of components whose information will be exported to xml file.
+        gds_comps_unit : str, optional
+            GDS_COMPONENTS section units. Default is ``"mm"``.
+        control_path : str, optional
+            Path for outputting the XML file.
+
+        Returns
+        -------
+        bool
+            ``True`` when successful, ``False`` when failed.
+        """
+        from pyedb.generic.general_methods import ET
+
+        components = ET.Element("GDS_COMPONENTS")
+        components.set("LengthUnit", gds_comps_unit)
+        if not comps_to_export:
+            comps_to_export = self.components.components
+        for comp in comps_to_export:
+            ocomp = self.components.components[comp]
+            gds_component = ET.SubElement(components, "GDS_COMPONENT")
+            for pin_name, pin in ocomp.pins.items():
+                pins_position_unit = unit_converter(pin.position, output_units=gds_comps_unit)
+                gds_pin = ET.SubElement(gds_component, "GDS_PIN")
+                gds_pin.set("Name", pin_name)
+                gds_pin.set("x", str(pins_position_unit[0]))
+                gds_pin.set("y", str(pins_position_unit[1]))
+                gds_pin.set("Layer", pin.placement_layer)
+            component = ET.SubElement(gds_component, "Component")
+            component.set("RefDes", ocomp.refdes)
+            component.set("PartName", ocomp.partname)
+            component.set("PartType", ocomp.type)
+        tree = ET.ElementTree(components)
+        ET.indent(tree, space="\t", level=0)
+        tree.write(control_path)
+        return True if os.path.exists(control_path) else False

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

@@ -33,7 +33,6 @@ 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
@@ -1009,204 +1008,3 @@ 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().ToString())
-                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")
-            ic_die_prop.SetType(getattr(self._edb.definition.DieType, snake_to_pascal(die_type)))
-            if not die_type == "no_die":
-                orientation = kwargs.get("orientation")
-                if orientation:
-                    ic_die_prop.SetOrientation(
-                        getattr(self._edb.definition.DieOrientation, snake_to_pascal(orientation))
-                    )
-                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

@@ -313,7 +313,7 @@ class Layout(ObjBase):
         """
         obj = self._pedb._edb.Cell.Net.FindByName(self._edb_object, value)
         if obj.IsNull():
-            raise ValueError(f"Net {value} doesn't exist")
+            return None
         else:
             return EDBNetsData(obj, self._pedb)
 

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

@@ -580,17 +580,17 @@ class Primitive(Connectable):
         _, name = self._edb_object.GetProductProperty(self._pedb._edb.ProductId.Designer, 1, val)
         name = str(name).strip("'")
         if name == "":
-            if str(self.primitive_type) == "Path":
+            if str(self.primitive_type).lower() == "path":
                 ptype = "line"
-            elif str(self.primitive_type) == "Rectangle":
+            elif str(self.primitive_type).lower() == "rectangle":
                 ptype = "rect"
-            elif str(self.primitive_type) == "Polygon":
+            elif str(self.primitive_type).lower() == "polygon":
                 ptype = "poly"
-            elif str(self.primitive_type) == "Bondwire":
+            elif str(self.primitive_type).lower() == "bondwire":
                 ptype = "bwr"
             else:
                 ptype = str(self.primitive_type).lower()
-            name = "{}_{}".format(ptype, self.id)
+            name = "{}__{}".format(ptype, self.id)
             self._edb_object.SetProductProperty(self._pedb._edb.ProductId.Designer, 1, name)
         return name
 
@@ -603,10 +603,6 @@ class Primitive(Connectable):
         """: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 add_void(self, point_list):
         """Add a void to current primitive.
 
@@ -757,24 +753,6 @@ class Primitive(Connectable):
             points.append(point)
         return points
 
-    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.
-        """
-        return self.polygon_data.expand(offset, tolerance, round_corners, maximum_corner_extension)
-
     def scale(self, factor, center=None):
         """Scales the polygon relative to a center point by a factor.
 

pyedb/dotnet/edb_core/edb_data/control_file.py

@@ -193,6 +193,19 @@ class ControlFileLayer:
             content.set("Thickness", self.properties.get("Thickness", "0.001"))
         if self.properties.get("Type"):
             content.set("Type", self.properties.get("Type", "conductor"))
+        if self.properties.get("ConvertPolygonToCircle"):
+            content.set("ConvertPolygonToCircle", self.properties["ConvertPolygonToCircle"])
+        if self.properties.get("ConvertPolygonToCircleRatio"):
+            content.set("ConvertPolygonToCircleRatio", self.properties["ConvertPolygonToCircleRatio"])
+        if self.properties.get("ReconstructArcs"):
+            content.set("ReconstructArcs", self.properties["ReconstructArcs"])
+        if self.properties.get("ArcTolerance"):
+            content.set("ArcTolerance", self.properties["ArcTolerance"])
+        if self.properties.get("UnionPrimitives"):
+            content.set("UnionPrimitives", self.properties["UnionPrimitives"])
+        # To confirm syntax with development
+        if self.properties.get("DefeatureMinTraceWidth"):
+            content.set("DefeatureMinTraceWidth", self.properties["DefeatureMinTraceWidth"])
 
 
 class ControlFileVia(ControlFileLayer):
@@ -226,6 +239,14 @@ class ControlFileVia(ControlFileLayer):
             content.set("Thickness", self.properties.get("Thickness", "0.001"))
         if self.properties.get("Type"):
             content.set("Type", self.properties.get("Type", "conductor"))
+        if self.properties.get("ConvertPolygonToCircle"):
+            content.set("ConvertPolygonToCircle", self.properties["ConvertPolygonToCircle"])
+        if self.properties.get("ConvertPolygonToCircleRatio"):
+            content.set("ConvertPolygonToCircleRatio", self.properties["ConvertPolygonToCircleRatio"])
+        if self.properties.get("ReconstructArcs"):
+            content.set("ReconstructArcs", self.properties["ReconstructArcs"])
+        if self.properties.get("ArcTolerance"):
+            content.set("ArcTolerance", self.properties["ArcTolerance"])
         if self.create_via_group:
             viagroup = ET.SubElement(content, "CreateViaGroups")
             viagroup.set("CheckContainment", "true" if self.check_containment else "false")