pyedb 0.2.0__py3-none-any.whl

pyedb/ipc2581/content/content.py

@@ -0,0 +1,55 @@
+from pyedb.generic.general_methods import ET
+from pyedb.ipc2581.content.dictionary_color import DictionaryColor
+from pyedb.ipc2581.content.dictionary_line import DictionaryLine
+from pyedb.ipc2581.content.layer_ref import LayerRef
+from pyedb.ipc2581.content.standard_geometries_dictionary import (
+    StandardGeometriesDictionary,
+)
+
+
+class Content(object):
+    def __init__(self, ipc):
+        self.mode = self.Mode().Stackup
+        self.units = ipc.units
+        self.role_ref = "Owner"
+        self.function_mode = self.Mode().Stackup
+        self.step_ref = "Ansys_IPC2581"
+        self._layer_ref = []
+        self.dict_colors = DictionaryColor()
+        self.dict_line = DictionaryLine(self)
+        self.standard_geometries_dict = StandardGeometriesDictionary(self)
+
+    @property
+    def layer_ref(self):
+        return self._layer_ref
+
+    @layer_ref.setter
+    def layer_ref(self, value):  # pragma no cover
+        if isinstance(value, list):
+            if len([lay for lay in value if isinstance(lay, LayerRef)]) == len(value):
+                self._layer_ref = value
+
+    def add_layer_ref(self, layer_ref_name=None):  # pragma no cover
+        if isinstance(layer_ref_name, str):
+            layer_ref = LayerRef()
+            layer_ref.name = layer_ref_name
+            self._layer_ref.append(layer_ref)
+
+    def write_wml(self, root=None):  # pragma no cover
+        content = ET.SubElement(root, "Content")
+        content.set("roleRef", "Owner")
+        if self.mode == self.Mode.Stackup:
+            function_mode = ET.SubElement(content, "FunctionMode")
+            function_mode.set("mode", "USERDEF")
+        step_ref = ET.SubElement(content, "StepRef")
+        step_ref.set("name", self.step_ref)
+        for lay in self.layer_ref:
+            lay.write_xml(content)
+        self.dict_colors.write_xml(content)
+        self.dict_line.write_xml(content)
+        self.standard_geometries_dict.write_xml(content)
+
+        # skipping user defined geometries
+
+    class Mode(object):
+        (Stackup) = range(1)

pyedb/ipc2581/content/dictionary_color.py

@@ -0,0 +1,29 @@
+from pyedb.generic.general_methods import ET
+from pyedb.ipc2581.content.entry_color import EntryColor
+
+
+class DictionaryColor(object):
+    def __init__(self):
+        self._dict_colors = []
+
+    @property
+    def dict_colors(self):
+        return self._dict_colors
+
+    @dict_colors.setter
+    def dict_colors(self, value):  # pragma no cover
+        if isinstance(value, list):
+            self._dict_colors = value
+
+    def add_color(self, name="", r=1, g=1, b=1):  # pragma no cover
+        entry_color = EntryColor()
+        entry_color.name = name
+        entry_color.color.r = r
+        entry_color.color.g = g
+        entry_color.color.b = b
+        self._dict_colors.append(entry_color)
+
+    def write_xml(self, content=None):  # pragma no cover
+        dict_color = ET.SubElement(content, "DictionaryColor")
+        for _color in self.dict_colors:
+            _color.write_xml(dict_color)

pyedb/ipc2581/content/dictionary_fill.py

@@ -0,0 +1,28 @@
+from pyedb.generic.general_methods import ET
+from pyedb.ipc2581.content.content import Content
+from pyedb.ipc2581.content.fill import FillDesc
+
+
+class DictionaryFill(Content):
+    def __init__(self):
+        self._dict_fill = {}
+
+    @property
+    def dict_fill(self):
+        return self._dict_fill
+
+    @dict_fill.setter
+    def dict_fill(self, value):  # pragma no cover
+        if isinstance(value, list):
+            self._dict_fill = value
+
+    def add_fill(self, value):  # pragma no cover
+        if isinstance(value, FillDesc):
+            self._dict_fill.append(value)
+
+    def write_xml(self, content=None):  # pragma no cover
+        if content:
+            dict_fill = ET.SubElement(content, "DictionaryFillDesc")
+            dict_fill.set("units", self.units)
+            for fill in self._dict_fill.keys():
+                self._dict_fill[fill].write_xml()

pyedb/ipc2581/content/dictionary_line.py

@@ -0,0 +1,30 @@
+from pyedb.generic.general_methods import ET
+from pyedb.ipc2581.content.entry_line import EntryLine
+
+
+class DictionaryLine(object):
+    def __init__(self, content):
+        self._dict_lines = {}
+        self.units = content.units
+
+    @property
+    def dict_lines(self):
+        return self._dict_lines
+
+    @dict_lines.setter
+    def dict_lines(self, value):  # pragma no cover
+        if isinstance(value, EntryLine):
+            self._dict_lines = value
+
+    def add_line(self, width=None):  # pragma no cover
+        if width:
+            line = EntryLine()
+            line._line_width = width
+            if not "ROUND_{}".format(width) in self._dict_lines:
+                self._dict_lines["ROUND_{}".format(width)] = line
+
+    def write_xml(self, content=None):  # pragma no cover
+        dict_line = ET.SubElement(content, "DictionaryLineDesc")
+        dict_line.set("units", self.units)
+        for line in list(self._dict_lines.values()):
+            line.write_xml(dict_line)

pyedb/ipc2581/content/entry_color.py

@@ -0,0 +1,13 @@
+from pyedb.generic.general_methods import ET
+from pyedb.ipc2581.content.color import Color
+
+
+class EntryColor(object):
+    def __init__(self):
+        self.name = ""
+        self.color = Color()
+
+    def write_xml(self, color=None):  # pragma no cover
+        entry_color = ET.SubElement(color, "EntryColor")
+        entry_color.set("id", self.name)
+        self.color.write_xml(entry_color)

pyedb/ipc2581/content/entry_line.py

@@ -0,0 +1,14 @@
+from pyedb.generic.general_methods import ET
+
+
+class EntryLine(object):
+    def __init__(self):
+        self._line_end = "ROUND"
+        self.line_width = ""
+
+    def write_xml(self, dictionnary_line):  # pragma no cover
+        entry_line = ET.SubElement(dictionnary_line, "EntryLineDesc")
+        entry_line.set("id", "{}_{}".format(self._line_end, self.line_width))
+        line_desc = ET.SubElement(entry_line, "LineDesc")
+        line_desc.set("lineEnd", self._line_end)
+        line_desc.set("lineWidth", str(self.line_width))

pyedb/ipc2581/content/fill.py

@@ -0,0 +1,15 @@
+from pyedb.generic.general_methods import ET
+from pyedb.ipc2581.content.content import Content
+
+
+class FillDesc(Content):
+    def __init__(self):
+        self.id = ""
+        self.fill_property = ""
+
+    def write_xml(self, dict_fill=None):  # pragma no cover
+        if dict_fill:
+            fill = ET.SubElement(dict_fill, "EntryFillDesc")
+            fill.set("id", self.id)
+            fill_desc = ET.SubElement(fill, "FillDesc")
+            fill_desc.set("fillProperty", self.fill_property)

pyedb/ipc2581/content/layer_ref.py

@@ -0,0 +1,10 @@
+from pyedb.generic.general_methods import ET
+
+
+class LayerRef(object):
+    def __init__(self):
+        self.name = ""
+
+    def write_xml(self, content=None):  # pragma no cover
+        layer_ref = ET.SubElement(content, "LayerRef")
+        layer_ref.set("name", self.name)

pyedb/ipc2581/content/standard_geometries_dictionary.py

@@ -0,0 +1,72 @@
+from pyedb.generic.general_methods import ET
+
+
+class StandardCircle(object):
+    def __init__(self):
+        self.diameter = ""
+        self.fill_id = ""
+
+    def write_xml(self, entry_standard):  # pragma no cover
+        standard_circle = ET.SubElement(entry_standard, "Circle")
+        standard_circle.set("diameter", self.diameter)
+        fill = ET.SubElement(standard_circle, "FillDescRef")
+        fill.set("id", self.fill_id)
+
+
+class RectangleDotNet(object):
+    def __init__(self):
+        self.width = ""
+        self.height = ""
+        self.fill_id = ""
+
+    def write_xml(self, entry_standard):  # pragma no cover
+        standard_rectanlgle = ET.SubElement(entry_standard, "RectCenter")
+        standard_rectanlgle.set("width", self.width)
+        standard_rectanlgle.set("height", self.height)
+        fill = ET.SubElement(standard_rectanlgle, "FillDescRef")
+        fill.set("id", self.fill_id)
+
+
+class Oval(object):
+    pass
+
+
+class Type(object):
+    (Circle, Rectangle) = range(0, 2)
+
+
+class StandardGeometriesDictionary(object):
+    def __init__(self, content):
+        self.units = content.units
+        self.standard_circ_dict = {}
+        self.standard_rect_dict = {}
+        self.standard_oval_dict = {}
+
+    def write_xml(self, content_section=None):  # pragma no cover
+        standard_dict = ET.SubElement(content_section, "DictionaryStandard")
+        standard_dict.set("units", self.units)
+        for standard_name, circle_val in self.standard_circ_dict.items():
+            if circle_val:
+                entry_standard = ET.SubElement(standard_dict, "EntryStandard")
+                entry_standard.set("id", standard_name)
+                circle = ET.SubElement(entry_standard, "Circle")
+                circle.set("diameter", str(circle_val))
+                fill_descref = ET.SubElement(circle, "FillDescRef")
+                fill_descref.set("id", "SOLID_FILL")
+        for standard_name, rect_val in self.standard_rect_dict.items():
+            if rect_val:
+                entry_standard = ET.SubElement(standard_dict, "EntryStandard")
+                entry_standard.set("id", standard_name)
+                rec_center = ET.SubElement(entry_standard, "RectCenter")
+                rec_center.set("width", str(rect_val[0]))
+                rec_center.set("height", str(rect_val[1]))
+                fill_descref = ET.SubElement(rec_center, "FillDescRef")
+                fill_descref.set("id", "SOLID_FILL")
+
+    def add_circle(self, diameter):  # pragma no cover
+        circle = StandardCircle()
+        circle.diameter = diameter
+        circle.fill_id = "SOLID_FILL"
+        entry_key = "CIRCLE_{}".format(diameter[0])
+        if not entry_key in self.standard_circ_dict:
+            self.standard_circ_dict[entry_key] = str(diameter[0])

pyedb/ipc2581/ecad/cad_data/assembly_drawing.py

@@ -0,0 +1,26 @@
+from pyedb.generic.general_methods import ET
+from pyedb.ipc2581.ecad.cad_data.polygon import Polygon
+
+
+class AssemblyDrawing(object):
+    """Class describing an IPC2581 assembly drawing."""
+
+    def __init__(self, ipc):
+        self._ipc = ipc
+        self.polygon = Polygon(self._ipc)
+        self.line_ref = ""
+
+    def write_xml(self, package):  # pragma no cover
+        assembly_drawing = ET.SubElement(package, "AssemblyDrawing")
+        outline = ET.SubElement(assembly_drawing, "Outline")
+        polygon = ET.SubElement(outline, "Polygon")
+        polygon_begin = ET.SubElement(polygon, "PolyBegin")
+        if self.polygon.poly_steps:
+            polygon_begin.set("x", str(self.polygon.poly_steps[0].x))
+            polygon_begin.set("y", str(self.polygon.poly_steps[0].y))
+            for poly_step in self.polygon.poly_steps[1:]:
+                polygon_segment = ET.SubElement(polygon, "PolyStepSegment")
+                polygon_segment.set("x", str(poly_step.x))
+                polygon_segment.set("y", str(poly_step.y))
+        line_desc_ref = ET.SubElement(outline, "LineDescRef")
+        line_desc_ref.set("id", self.line_ref)

pyedb/ipc2581/ecad/cad_data/cad_data.py

@@ -0,0 +1,37 @@
+from pyedb.generic.general_methods import ET
+from pyedb.ipc2581.ecad.cad_data.layer import Layer
+from pyedb.ipc2581.ecad.cad_data.stackup import Stackup
+from pyedb.ipc2581.ecad.cad_data.step import Step
+
+
+class CadData(object):
+    def __init__(self, ecad, edb, units, ipc):
+        self.design_name = ecad.design_name
+        self._pedb = edb
+        self._ipc = ipc
+        self.units = units
+        self._layers = []
+        self.stackup = Stackup()
+        self.cad_data_step = Step(self, edb, self.units, self._ipc)
+
+    @property
+    def layers(self):
+        return self._layers
+
+    def add_layer(
+        self, layer_name="", layer_function="", layer_side="internal", polarity="positive"
+    ):  # pragma no cover
+        layer = Layer()
+        layer.name = layer_name
+        layer.layer_function = layer_function
+        layer.layer_side = layer_side
+        layer.layer_polarity = polarity
+        self.layers.append(layer)
+
+    def write_xml(self, ecad):  # pragma no cover
+        self.design_name = self._pedb.cell_names[0]
+        cad_data = ET.SubElement(ecad, "CadData")
+        for layer in self.layers:
+            layer.write_xml(cad_data)
+        self.stackup.write_xml(cad_data)
+        self.cad_data_step.write_xml(cad_data)

pyedb/ipc2581/ecad/cad_data/component.py

@@ -0,0 +1,41 @@
+from pyedb.generic.general_methods import ET
+
+
+class Component(object):
+    """Contains IPC2581 component information."""
+
+    def __init__(self):
+        self.refdes = ""
+        self.package_ref = ""
+        self.layer_ref = ""
+        self.part = ""
+        self.mount_type = "SMT"
+        self.stand_off = "0.0"
+        self.height = "0.0"
+        self.location = ["0.0", "0.0"]
+        self.rotation = "0.0"
+        self.type = Type().Rlc
+        self.value = ""
+
+    def write_xml(self, step):  # pragma no cover
+        component = ET.SubElement(step, "Component")
+        component.set("refDes", self.refdes)
+        component.set("packageRef", self.package_ref)
+        component.set("layerRef", self.layer_ref)
+        component.set("part", self.package_ref)
+        component.set("mountType", self.mount_type)
+        component.set("standoff", self.stand_off)
+        component.set("height", self.height)
+        non_standard_attribute = ET.SubElement(component, "NonstandardAttribute")
+        non_standard_attribute.set("name", "VALUE")
+        non_standard_attribute.set("value", str(self.value))
+        non_standard_attribute.set("type", "STRING")
+        xform = ET.SubElement(component, "Xform")
+        xform.set("rotation", str(self.rotation))
+        location = ET.SubElement(component, "Location")
+        location.set("x", str(self.location[0]))
+        location.set("y", str(self.location[1]))
+
+
+class Type(object):
+    (Rlc, Discrete) = range(0, 2)

pyedb/ipc2581/ecad/cad_data/drill.py

@@ -0,0 +1,30 @@
+from pyedb.generic.general_methods import ET
+
+
+class Drill(object):
+    """Class describing an ICP2581 drill feature."""
+
+    def __init__(self):
+        self.net = ""
+        self.component = ""
+        self.geometry = "VIA"
+        self.hole_name = ""
+        self.diameter = ""
+        self.plating_status = "VIA"
+        self.plus_tol = "0.0"
+        self.min_tol = "0.0"
+        self.x = "0.0"
+        self.y = "0.0"
+
+    def write_xml(self, net):  # pragma no cover
+        net.set("geometry", "VIA")
+        color_ref = ET.SubElement(net, "ColorRef")
+        color_ref.set("id", "")
+        hole = ET.SubElement(net, "Hole")
+        hole.set("name", self.hole_name)
+        hole.set("diameter", str(self.diameter))
+        hole.set("platingStatus", "VIA")
+        hole.set("plusTol", str(self.plus_tol))
+        hole.set("minusTol", str(self.min_tol))
+        hole.set("x", str(self.x))
+        hole.set("y", str(self.y))

pyedb/ipc2581/ecad/cad_data/feature.py

@@ -0,0 +1,54 @@
+from pyedb.generic.general_methods import ET
+from pyedb.ipc2581.ecad.cad_data.drill import Drill
+from pyedb.ipc2581.ecad.cad_data.padstack_instance import PadstackInstance
+from pyedb.ipc2581.ecad.cad_data.path import Path
+from pyedb.ipc2581.ecad.cad_data.polygon import Polygon
+
+
+class Feature(object):
+    """Class describing IPC2581 features."""
+
+    def __init__(self, ipc):
+        self._ipc = ipc
+        self.feature_type = FeatureType().Polygon
+        self.net = ""
+        self.x = 0.0
+        self.y = 0.0
+        self.polygon = Polygon(self._ipc)
+        self._cutouts = []
+        self.path = Path(self._ipc)
+        # self.pad = PadstackDef()
+        self.padstack_instance = PadstackInstance()
+        self.drill = Drill()
+        # self.via = Via()
+
+    @property
+    def cutouts(self):
+        return self._cutouts
+
+    @cutouts.setter
+    def cutouts(self, value):  # pragma no cover
+        if isinstance(value, list):
+            if len([poly for poly in value if isinstance(poly, Polygon)]) == len(value):
+                self._cutouts = value
+
+    def add_cutout(self, cutout=None):  # pragma no cover
+        if isinstance(cutout, Polygon):
+            self._cutouts.append(cutout)
+
+    def write_xml(self, layer_feature):  # pragma no cover
+        net = ET.SubElement(layer_feature, "Set")
+        net.set("net", self.net)
+        if self.feature_type == FeatureType.Polygon:
+            self.polygon.write_xml(net)
+        elif self.feature_type == FeatureType.Path:
+            self.path.write_xml(net)
+        elif self.feature_type == FeatureType.PadstackInstance:
+            net.set("net", self.padstack_instance.net)
+            self.padstack_instance.write_xml(net)
+        elif self.feature_type == FeatureType.Drill:
+            self.drill.write_xml(net)
+
+
+class FeatureType:
+    (Polygon, Path, PadstackInstance, Drill) = range(0, 4)

pyedb/ipc2581/ecad/cad_data/layer.py

@@ -0,0 +1,41 @@
+from pyedb.generic.general_methods import ET
+
+
+class Layer(object):
+    def __init__(self):
+        self.name = ""
+        self._layer_function = ""
+        self._layer_side = ""
+        self._layer_polarity = ""
+        self.sequence = 0
+
+    @property
+    def layer_function(self):
+        return self._layer_function
+
+    @layer_function.setter
+    def layer_function(self, value):  # pragma no cover
+        self._layer_function = value
+
+    @property
+    def layer_side(self):
+        return self._layer_side
+
+    @layer_side.setter
+    def layer_side(self, value):  # pragma no cover
+        self._layer_side = value
+
+    @property
+    def layer_polarity(self):
+        return self._layer_polarity
+
+    @layer_polarity.setter
+    def layer_polarity(self, value):  # pragma no cover
+        self._layer_polarity = value
+
+    def write_xml(self, cad_data):  # pragma no cover
+        layer = ET.SubElement(cad_data, "Layer")
+        layer.set("name", self.name)
+        layer.set("layerFunction", self.layer_function)
+        layer.set("side", self.layer_side)
+        layer.set("polarity", self.layer_polarity)

pyedb/ipc2581/ecad/cad_data/layer_feature.py

@@ -0,0 +1,151 @@
+import math
+
+from pyedb.generic.general_methods import ET, pyedb_function_handler
+from pyedb.ipc2581.ecad.cad_data.feature import Feature, FeatureType
+
+
+class LayerFeature(object):
+    """Class describing IPC2581 layer feature."""
+
+    def __init__(self, ipc):
+        self._ipc = ipc
+        self.layer_name = ""
+        self.color = ""
+        self._features = []
+        self.is_drill_feature = False
+
+    @property
+    def features(self):
+        return self._features
+
+    @features.setter
+    def features(self, value):  # pragma no cover
+        if isinstance(value, list):
+            if len([feat for feat in value if isinstance(feat, Feature)]) == len(value):
+                self._features = value
+
+    @pyedb_function_handler()
+    def add_feature(self, obj_instance=None):  # pragma no cover
+        if obj_instance:
+            feature = Feature(self._ipc)
+            feature.net = obj_instance.net_name
+            if obj_instance.type == "Polygon":
+                feature.feature_type = FeatureType.Polygon
+                feature.polygon.add_poly_step(obj_instance)
+            elif obj_instance.type == "Path":
+                feature.feature_type = FeatureType.Path
+                feature.path.add_path_step(obj_instance)
+            self.features.append(feature)
+        else:
+            return False
+
+    @pyedb_function_handler()
+    def add_via_instance_feature(self, padstack_inst=None, padstackdef=None, layer_name=None):  # pragma no cover
+        if padstack_inst and padstackdef:
+            feature = Feature(self._ipc)
+            def_name = padstackdef.name
+            position = padstack_inst.position if padstack_inst.position else padstack_inst.position
+            feature.padstack_instance.net = padstack_inst.net_name
+            feature.padstack_instance.isvia = True
+            feature.padstack_instance.padstack_def = def_name
+            feature.feature_type = FeatureType.PadstackInstance
+            feature.padstack_instance.x = self._ipc.from_meter_to_units(position[0], self._ipc.units)
+            feature.padstack_instance.y = self._ipc.from_meter_to_units(position[1], self._ipc.units)
+            if padstackdef._hole_params is None:
+                hole_props = [i.ToDouble() for i in padstackdef.hole_params[2]]
+            else:
+                hole_props = [i.ToDouble() for i in padstackdef._hole_params[2]]
+            feature.padstack_instance.diameter = float(hole_props[0]) if hole_props else 0
+            feature.padstack_instance.hole_name = def_name
+            feature.padstack_instance.name = padstack_inst.name
+            try:
+                if padstackdef.pad_by_layer[layer_name].parameters_values is None:
+                    feature.padstack_instance.standard_primimtive_ref = "CIRCLE_{}".format(
+                        self._ipc.from_meter_to_units(
+                            padstackdef.pad_by_layer[layer_name].parameters_values[0], self._ipc.units
+                        )
+                    )
+                else:
+                    feature.padstack_instance.standard_primimtive_ref = "CIRCLE_{}".format(
+                        self._ipc.from_meter_to_units(
+                            padstackdef.pad_by_layer[layer_name].parameters_values[0], self._ipc.units
+                        )
+                    )
+                self.features.append(feature)
+            except:
+                pass
+
+    @pyedb_function_handler()
+    def add_drill_feature(self, via, diameter=0.0):  # pragma no cover
+        feature = Feature(self._ipc)
+        feature.feature_type = FeatureType.Drill
+        feature.drill.net = via.net_name
+        position = via._position if via._position else via.position
+        feature.drill.x = self._ipc.from_meter_to_units(position[0], self._ipc.units)
+        feature.drill.y = self._ipc.from_meter_to_units(via.position[1], self._ipc.units)
+        feature.drill.diameter = self._ipc.from_meter_to_units(diameter, self._ipc.units)
+        self.features.append(feature)
+
+    @pyedb_function_handler()
+    def add_component_padstack_instance_feature(
+        self, component=None, pin=None, top_bottom_layers=[], padstack_def=None
+    ):  # pragma no cover
+        if component:
+            if pin:
+                is_via = False
+                if not pin.start_layer == pin.stop_layer:
+                    is_via = True
+                pin_net = pin.GetNet().GetName()
+                pos_rot = pin._edb_padstackinstance.GetPositionAndRotationValue()
+                pin_rotation = pos_rot[2].ToDouble()
+                if pin._edb_padstackinstance.IsLayoutPin():
+                    out2 = pin._edb_padstackinstance.GetComponent().GetTransform().TransformPoint(pos_rot[1])
+                    pin_position = [out2.X.ToDouble(), out2.Y.ToDouble()]
+                else:
+                    pin_position = [pos_rot[1].X.ToDouble(), pos_rot[1].Y.ToDouble()]
+                pin_x = self._ipc.from_meter_to_units(pin_position[0], self._ipc.units)
+                pin_y = self._ipc.from_meter_to_units(pin_position[1], self._ipc.units)
+                cmp_rot_deg = component.rotation * 180 / math.pi
+                mirror = False
+                rotation = cmp_rot_deg + pin_rotation * 180 / math.pi
+                if rotation < 0:
+                    rotation += 360
+                comp_placement_layer = component.placement_layer
+                if comp_placement_layer == top_bottom_layers[-1]:
+                    mirror = True
+                feature = Feature(self._ipc)
+                feature.feature_type = FeatureType.PadstackInstance
+                feature.net = pin_net
+                feature.padstack_instance.net = pin_net
+                feature.padstack_instance.pin = pin.pin.GetName()
+                feature.padstack_instance.x = pin_x
+                feature.padstack_instance.y = pin_y
+                feature.padstack_instance.rotation = rotation
+                feature.padstack_instance.mirror = mirror
+                feature.padstack_instance.isvia = is_via
+                feature.padstack_instance.refdes = component.refdes
+                feature.padstack_instance.padstack_def = padstack_def.name
+                primitive_ref = self._get_primitive_ref(padstack_def.name, comp_placement_layer)
+                if primitive_ref == "default_value":
+                    other_layer = [lay for lay in top_bottom_layers if lay != comp_placement_layer][0]
+                    primitive_ref = self._get_primitive_ref(padstack_def.name, other_layer)
+                feature.padstack_instance.standard_primimtive_ref = primitive_ref
+                self.features.append(feature)
+
+    @pyedb_function_handler()
+    def _get_primitive_ref(self, padstack_def=None, layer=None):
+        if padstack_def and layer:
+            for pad_def in self._ipc.ecad.cad_data.cad_data_step.padstack_defs[padstack_def].padstack_pad_def:
+                if pad_def.layer_ref == layer:
+                    return pad_def.primitive_ref
+            return "default_value"
+
+    @pyedb_function_handler()
+    def write_xml(self, step):  # pragma no cover
+        layer_feature = ET.SubElement(step, "LayerFeature")
+        layer_feature.set("layerRef", self.layer_name)
+        color_set = ET.SubElement(layer_feature, "Set")
+        color_ref = ET.SubElement(color_set, "ColorRef")
+        color_ref.set("id", self.layer_name)
+        for feature in self.features:
+            feature.write_xml(layer_feature)