pyedb 0.2.0__py3-none-any.whl

pyedb/ipc2581/ecad/cad_data/polygon.py

@@ -0,0 +1,169 @@
+import math
+
+from pyedb.generic.general_methods import ET, pyedb_function_handler
+
+
+class Polygon(object):
+    def __init__(self, ipc):
+        self._ipc = ipc
+        self.is_void = False
+        self.poly_steps = []
+        self.solid_fill_id = ""
+        self.cutout = []
+
+    @pyedb_function_handler()
+    def add_poly_step(self, polygon=None):  # pragma no cover
+        if polygon:
+            polygon_data = polygon.GetPolygonData()
+            if polygon_data.IsClosed():
+                arcs = polygon_data.GetArcData()
+                if not arcs:
+                    return
+                # begin
+                new_segment_tep = PolyStep()
+                new_segment_tep.poly_type = PolyType.Segment
+                new_segment_tep.x = arcs[0].Start.X.ToDouble()
+                new_segment_tep.y = arcs[0].Start.Y.ToDouble()
+                self.poly_steps.append(new_segment_tep)
+                for arc in arcs:
+                    if arc.Height == 0:
+                        new_segment_tep = PolyStep()
+                        new_segment_tep.poly_type = PolyType.Segment
+                        new_segment_tep.x = arc.End.X.ToDouble()
+                        new_segment_tep.y = arc.End.Y.ToDouble()
+                        self.poly_steps.append(new_segment_tep)
+                    else:
+                        arc_center = arc.GetCenter()
+                        new_poly_step = PolyStep()
+                        new_poly_step.poly_type = PolyType.Curve
+                        new_poly_step.center_X = arc_center.X.ToDouble()
+                        new_poly_step.center_y = arc_center.Y.ToDouble()
+                        new_poly_step.x = arc.End.X.ToDouble()
+                        new_poly_step.y = arc.End.Y.ToDouble()
+                        new_poly_step.clock_wise = not arc.IsCCW()
+                        self.poly_steps.append(new_poly_step)
+                for void in polygon.voids:
+                    void_polygon_data = void.GetPolygonData()
+                    if void_polygon_data.IsClosed():
+                        void_arcs = void_polygon_data.GetArcData()
+                        if not void_arcs:
+                            return
+                        void_polygon = Cutout(self._ipc)
+                        self.cutout.append(void_polygon)
+                        # begin
+                        new_segment_tep = PolyStep()
+                        new_segment_tep.poly_type = PolyType.Segment
+                        new_segment_tep.x = void_arcs[0].Start.X.ToDouble()
+                        new_segment_tep.y = void_arcs[0].Start.Y.ToDouble()
+                        void_polygon.poly_steps.append(new_segment_tep)
+                        for void_arc in void_arcs:
+                            if void_arc.Height == 0:
+                                new_segment_tep = PolyStep()
+                                new_segment_tep.poly_type = PolyType.Segment
+                                new_segment_tep.x = void_arc.End.X.ToDouble()
+                                new_segment_tep.y = void_arc.End.Y.ToDouble()
+                                void_polygon.poly_steps.append(new_segment_tep)
+                            else:
+                                arc_center = void_arc.GetCenter()
+                                new_poly_step = PolyStep()
+                                new_poly_step.poly_type = PolyType.Curve
+                                new_poly_step.center_X = arc_center.X.ToDouble()
+                                new_poly_step.center_y = arc_center.Y.ToDouble()
+                                new_poly_step.x = void_arc.End.X.ToDouble()
+                                new_poly_step.y = void_arc.End.Y.ToDouble()
+                                new_poly_step.clock_wise = not void_arc.IsCCW()
+                                void_polygon.poly_steps.append(new_poly_step)
+
+    @pyedb_function_handler()
+    def add_cutout(self, cutout):  # pragma no cover
+        if not isinstance(cutout, Cutout):
+            return False
+        self.cutout.append(cutout)
+
+    @pyedb_function_handler()
+    def write_xml(self, root_net):  # pragma no cover
+        if not self.poly_steps:
+            return
+        feature = ET.SubElement(root_net, "Features")
+        location = ET.SubElement(feature, "Location")
+        location.set("x", str(0))
+        location.set("y", str(0))
+        contour = ET.SubElement(feature, "Contour")
+        polygon = ET.SubElement(contour, "Polygon")
+        polygon_begin = ET.SubElement(polygon, "PolyBegin")
+        polygon_begin.set("x", str(self._ipc.from_meter_to_units(self.poly_steps[0].x, self._ipc.units)))
+        polygon_begin.set("y", str(self._ipc.from_meter_to_units(self.poly_steps[0].y, self._ipc.units)))
+        for poly_step in self.poly_steps[1:]:
+            poly_step.write_xml(polygon, self._ipc)
+        for cutout in self.cutout:
+            cutout.write_xml(contour, self._ipc)
+
+
+class Cutout(object):
+    def __init__(self, ipc):
+        self._ipc = ipc
+        self.poly_steps = []
+
+    @pyedb_function_handler()
+    def write_xml(self, contour, ipc):  # pragma no cover
+        cutout = ET.SubElement(contour, "Cutout")
+        cutout_begin = ET.SubElement(cutout, "PolyBegin")
+        cutout_begin.set("x", str(ipc.from_meter_to_units(self.poly_steps[0].x, ipc.units)))
+        cutout_begin.set("y", str(ipc.from_meter_to_units(self.poly_steps[0].y, ipc.units)))
+        for poly_step in self.poly_steps[1:]:
+            if poly_step.poly_type == 0:
+                poly = ET.SubElement(cutout, "PolyStepSegment")
+                poly.set("x", str(ipc.from_meter_to_units(poly_step.x, ipc.units)))
+                poly.set("y", str(ipc.from_meter_to_units(poly_step.y, ipc.units)))
+            elif poly_step.poly_type == 1:
+                poly = ET.SubElement(cutout, "PolyStepCurve")
+                poly.set("x", str(ipc.from_meter_to_units(poly_step.x, ipc.units)))
+                poly.set("y", str(ipc.from_meter_to_units(poly_step.y, ipc.units)))
+                poly.set("centerX", str(ipc.from_meter_to_units(poly_step.center_X, ipc.units)))
+                poly.set("centerY", str(ipc.from_meter_to_units(poly_step.center_y, ipc.units)))
+                poly.set("clockwise", str(poly_step.clock_wise).lower())
+
+
+class PolyStep(object):
+    def __init__(self):
+        self.poly_type = PolyType().Segment
+        self.x = 0.0
+        self.y = 0.0
+        self.center_X = 0.0
+        self.center_y = 0.0
+        self.clock_wise = False
+
+    @pyedb_function_handler()
+    def write_xml(self, polygon, ipc):  # pragma no cover
+        if self.poly_type == 0:
+            poly = ET.SubElement(polygon, "PolyStepSegment")
+            poly.set("x", str(ipc.from_meter_to_units(self.x, ipc.units)))
+            poly.set("y", str(ipc.from_meter_to_units(self.y, ipc.units)))
+        elif self.poly_type == 1:
+            poly = ET.SubElement(polygon, "PolyStepCurve")
+            poly.set("x", str(ipc.from_meter_to_units(self.x, ipc.units)))
+            poly.set("y", str(ipc.from_meter_to_units(self.y, ipc.units)))
+            poly.set("centerX", str(ipc.from_meter_to_units(self.center_X, ipc.units)))
+            poly.set("centerY", str(ipc.from_meter_to_units(self.center_y, ipc.units)))
+            poly.set("clockwise", str(self.clock_wise).lower())
+
+
+class PolyType(object):
+    (Segment, Curve) = range(0, 2)
+
+
+class Curve(object):
+    def __init__(self):
+        self.center_X = 0.0
+        self.center_y = 0.0
+        self.clock_wise = False
+
+
+class Arc(object):
+    @staticmethod
+    def get_arc_radius_angle(h, c):  # pragma no cover
+        if not isinstance(h, float) and isinstance(c, float):
+            return False
+        r = h / 2 + math.pow(c, 2) / (8 * h)
+        theta = 2 * math.asin(c / (2 * r))
+        return r, theta

pyedb/ipc2581/ecad/cad_data/profile.py

@@ -0,0 +1,40 @@
+from pyedb.generic.general_methods import ET
+from pyedb.ipc2581.ecad.cad_data.layer_feature import LayerFeature
+
+
+class Profile(object):
+    def __init__(self, ipc):
+        self._profile = []
+        self._ipc = ipc
+
+    @property
+    def profile(self):
+        return self._profile
+
+    @profile.setter
+    def profile(self, value):  # pragma no cover
+        if isinstance(value, list):
+            if len([poly for poly in value if isinstance(poly, LayerFeature)]) == len(value):
+                self._profile = value
+
+    def add_polygon(self, polygon):  # pragma no cover
+        if isinstance(polygon, LayerFeature):
+            self._profile.append(polygon)
+
+    def xml_writer(self, step):  # pragma no cover
+        profile = ET.SubElement(step, "Profile")
+        for poly in self.profile:
+            for feature in poly.features:
+                if feature.feature_type == 0:
+                    polygon = ET.SubElement(profile, "Polygon")
+                    polygon_begin = ET.SubElement(polygon, "PolyBegin")
+                    polygon_begin.set(
+                        "x", str(self._ipc.from_meter_to_units(feature.polygon.poly_steps[0].x, self._ipc.units))
+                    )
+                    polygon_begin.set(
+                        "y", str(self._ipc.from_meter_to_units(feature.polygon.poly_steps[0].y, self._ipc.units))
+                    )
+                    for poly_step in feature.polygon.poly_steps[1:]:
+                        poly_step.write_xml(polygon, self._ipc)
+                    for cutout in feature.polygon.cutout:
+                        cutout.write_xml(profile, self._ipc)

pyedb/ipc2581/ecad/cad_data/stackup.py

@@ -0,0 +1,31 @@
+from pyedb.generic.general_methods import ET
+from pyedb.ipc2581.ecad.cad_data.stackup_group import StackupGroup
+
+
+class Stackup(object):
+    def __init__(self):
+        self.name = "PRIMARY"
+        self.total_thickness = 0.0
+        self.tol_plus = 0.0
+        self.tol_min = 0.0
+        self.where_measured = "METAL"
+        self._stackup_group = StackupGroup()
+
+    @property
+    def stackup_group(self):
+        return self._stackup_group
+
+    @stackup_group.setter
+    def stackup_group(self, value):  # pragma no cover
+        if isinstance(value, list):
+            if len([stack_grp for stack_grp in value if isinstance(stack_grp, StackupGroup)]):
+                self._stackup_group = value
+
+    def write_xml(self, cad_data):  # pragma no cover
+        stackup = ET.SubElement(cad_data, "Stackup")
+        stackup.set("name", self.name)
+        stackup.set("overallThickness", str(self.total_thickness))
+        stackup.set("tolPlus", str(self.tol_plus))
+        stackup.set("tolMinus", str(self.tol_min))
+        stackup.set("whereMeasured", self.where_measured)
+        self.stackup_group.write_xml(stackup)

pyedb/ipc2581/ecad/cad_data/stackup_group.py

@@ -0,0 +1,42 @@
+from pyedb.generic.general_methods import ET
+from pyedb.ipc2581.ecad.cad_data.layer import Layer
+from pyedb.ipc2581.ecad.cad_data.stackup_layer import StackupLayer
+
+
+class StackupGroup(object):
+    def __init__(self):
+        self.name = "GROUP_PRIMARY"
+        self.thickness = 0
+        self.tol_plus = 0
+        self.tol_minus = 0
+        self._stackup_layers = []
+
+    @property
+    def stackup_layers(self):
+        return self._stackup_layers
+
+    @stackup_layers.setter
+    def stackup_layers(self, value):  # pragma no cover
+        if isinstance(value, list):
+            if len([lay for lay in value if isinstance(lay, Layer)]):
+                self._stackup_layers = value
+
+    def add_stackup_layer(
+        self, layer_name="", thickness="", tol_minus="0.0", tol_plus="0.0", sequence=""
+    ):  # pragma no cover
+        stackup_layer = StackupLayer()
+        stackup_layer.layer_name = layer_name
+        stackup_layer.thickness = thickness
+        stackup_layer.tol_plus = tol_plus
+        stackup_layer.tol_minus = tol_minus
+        stackup_layer.sequence = sequence
+        self._stackup_layers.append(stackup_layer)
+
+    def write_xml(self, stackup):  # pragma no cover
+        stackup_group = ET.SubElement(stackup, "StackupGroup")
+        stackup_group.set("name", "GROUP_PRIMARY")
+        stackup_group.set("thickness", str(self.thickness))
+        stackup_group.set("tolPlus", str(self.tol_plus))
+        stackup_group.set("tolMinus", str(self.tol_minus))
+        for layer in self.stackup_layers:
+            layer.write_xml(stackup_group)

pyedb/ipc2581/ecad/cad_data/stackup_layer.py

@@ -0,0 +1,21 @@
+from pyedb.generic.general_methods import ET
+
+
+class StackupLayer(object):
+    def __init__(self):
+        self.layer_name = ""
+        self.thickness = 0
+        self.tol_minus = 0
+        self.tol_plus = 0
+        self.sequence = ""
+        self.spec_ref = "SPEC_{}".format(self.layer_name)
+
+    def write_xml(self, stackup_group):  # pragma no cover
+        stackup_layer = ET.SubElement(stackup_group, "StackupLayer")
+        stackup_layer.set("layerOrGroupRef", self.layer_name)
+        stackup_layer.set("thickness", str(self.thickness))
+        stackup_layer.set("tolPlus", str(self.tol_plus))
+        stackup_layer.set("tolMinus", str(self.tol_minus))
+        stackup_layer.set("sequence", self.sequence)
+        spec_ref = ET.SubElement(stackup_layer, "SpecRef")
+        spec_ref.set("id", self.layer_name)

pyedb/ipc2581/ecad/cad_data/step.py

@@ -0,0 +1,275 @@
+import math
+
+from pyedb.generic.general_methods import ET, pyedb_function_handler
+from pyedb.ipc2581.ecad.cad_data.component import Component
+from pyedb.ipc2581.ecad.cad_data.layer_feature import LayerFeature
+from pyedb.ipc2581.ecad.cad_data.logical_net import LogicalNet
+from pyedb.ipc2581.ecad.cad_data.package import Package
+from pyedb.ipc2581.ecad.cad_data.padstack_def import PadstackDef
+from pyedb.ipc2581.ecad.cad_data.phy_net import PhyNet
+from pyedb.ipc2581.ecad.cad_data.profile import Profile
+
+
+class Step(object):
+    def __init__(self, caddata, edb, units, ipc):
+        self.design_name = caddata.design_name
+        self._pedb = edb
+        self._ipc = ipc
+        self.units = units
+        self._cad_data = caddata
+        self._padstack_defs = {}
+        self._profile = Profile(ipc)
+        self._packages = {}
+        self._components = []
+        self._logical_nets = []
+        self._physical_nets = []
+        self._layer_features = []
+
+    @property
+    def padstack_defs(self):
+        return self._padstack_defs
+
+    @padstack_defs.setter
+    def padstack_defs(self, value):  # pragma no cover
+        if isinstance(value, list):
+            if len([pad for pad in value if isinstance(pad, PadstackDef)]) == len(value):
+                self._padstack_defs = value
+
+    @property
+    def packages(self):
+        return self._packages
+
+    @packages.setter
+    def packages(self, value):  # pragma no cover
+        if isinstance(value, list):
+            if len([pkg for pkg in value if isinstance(pkg, Package)]) == len(value):
+                self._packages = value
+
+    @property
+    def profile(self):
+        return self._profile
+
+    @property
+    def components(self):
+        return self._components
+
+    @components.setter
+    def components(self, value):  # pragma no cover
+        if isinstance(value, list):
+            if len([cmp for cmp in value if isinstance(cmp, Component)]) == len(value):
+                self._components = value
+
+    @property
+    def logical_nets(self):
+        return self._logical_nets
+
+    @pyedb_function_handler()
+    def add_logical_net(self, net=None):  # pragma no cover
+        net_name = net.name
+        logical_net = LogicalNet()
+        logical_net.name = net_name
+        net_pins = list(net.PadstackInstances)
+        for pin in net_pins:
+            new_pin_ref = logical_net.get_pin_ref_def()
+            new_pin_ref.pin = pin.GetName()
+            new_pin_ref.component_ref = pin.GetComponent().GetName()
+            logical_net.pin_ref.append(new_pin_ref)
+        self.logical_nets.append(logical_net)
+
+    @property
+    def layer_features(self):
+        return self._layer_features
+
+    @layer_features.setter
+    def layer_features(self, value):  # pragma no cover
+        if isinstance(value, list):
+            if len(
+                [
+                    feat
+                    for feat in value
+                    if isinstance(
+                        feat,
+                    )
+                ]
+            ):
+                self._layer_features = value
+
+    @property
+    def physical_nets(self):
+        return self._physical_nets
+
+    @physical_nets.setter
+    def physical_nets(self, value):  # pragma no cover
+        if isinstance(value, list):
+            if len([phy_net for phy_net in value if isinstance(phy_net, PhyNet)]) == len(value):
+                self._physical_nets = value
+
+    @pyedb_function_handler()
+    def add_physical_net(self, phy_net=None):  # pragma no cover
+        if isinstance(phy_net, PhyNet):
+            self._physical_nets.append(phy_net)
+            return True
+        return False
+
+    @pyedb_function_handler()
+    def add_padstack_def(self, padstackdef=None):  # pragma no cover
+        if isinstance(padstackdef, PadstackDef):
+            self._padstack_defs.append(padstackdef)
+
+    @pyedb_function_handler()
+    def add_component(self, component=None):  # pragma no cover
+        # adding component add package in Step
+        if component:
+            if not component.part_name in self._packages:
+                package = Package(self._ipc)
+                package.add_component_outline(component)
+                package.name = component.part_name
+                package.height = ""
+                package.type = component.type
+                pin_number = 0
+                for _, pin in component.pins.items():
+                    geometry_type, pad_parameters, pos_x, pos_y, rot = self._pedb.padstacks.get_pad_parameters(
+                        pin._edb_padstackinstance, component.placement_layer, 0
+                    )
+                    if pad_parameters:
+                        position = pin._position if pin._position else pin.position
+                        pin_pos_x = self._ipc.from_meter_to_units(position[0], self.units)
+                        pin_pos_y = self._ipc.from_meter_to_units(position[1], self.units)
+                        primitive_ref = ""
+                        if geometry_type == 1:
+                            primitive_ref = "CIRC_{}".format(pad_parameters[0])
+                        elif geometry_type == 2:
+                            primitive_ref = "RECT_{}_{}".format(pad_parameters[0], pad_parameters[0])
+                        elif geometry_type == 3:
+                            primitive_ref = "RECT_{}_{}".format(pad_parameters[0], pad_parameters[1])
+                        elif geometry_type == 4:
+                            primitive_ref = "OVAL_{}_{}_{}".format(
+                                pad_parameters[0], pad_parameters[1], pad_parameters[2]
+                            )
+                        if primitive_ref:
+                            package.add_pin(
+                                number=pin_number, x=pin_pos_x, y=pin_pos_y, rotation=rot, primitive_ref=primitive_ref
+                            )
+                        pin_number += 1
+                self.packages[package.name] = package
+            ipc_component = Component()
+            ipc_component.type = component.type
+            try:
+                ipc_component.value = component.value
+            except:
+                pass
+            ipc_component.refdes = component.refdes
+            center = component.center
+            ipc_component.location = [
+                self._ipc.from_meter_to_units(center[0], self.units),
+                self._ipc.from_meter_to_units(center[1], self.units),
+            ]
+            ipc_component.rotation = component.rotation * 180 / math.pi
+            ipc_component.part = ipc_component.package_ref = component.part_name
+            ipc_component.layer_ref = component.placement_layer
+            self.components.append(ipc_component)
+
+    def layer_ranges(
+        self,
+        start_layer,
+        stop_layer,
+    ):  # pragma no cover
+        started = False
+        start_layer_name = start_layer.GetName()
+        stop_layer_name = stop_layer.GetName()
+        layer_list = []
+        for layer_name in self._ipc.layers_name:
+            if started:
+                layer_list.append(layer_name)
+                if layer_name == stop_layer_name or layer_name == start_layer_name:
+                    break
+            elif layer_name == start_layer_name:
+                started = True
+                layer_list.append(layer_name)
+                if layer_name == stop_layer_name:
+                    break
+            elif layer_name == stop_layer_name:
+                started = True
+                layer_list.append(layer_name)
+                if layer_name == start_layer_name:
+                    break
+        return layer_list
+
+    @pyedb_function_handler()
+    def add_layer_feature(self, layer, polys):  # pragma no cover
+        layer_name = layer.name
+        layer_feature = LayerFeature(self._ipc)
+        layer_feature.layer_name = layer_name
+        layer_feature.color = layer.color
+
+        for poly in polys:
+            if not poly.is_void:
+                layer_feature.add_feature(poly)
+        self._ipc.ecad.cad_data.cad_data_step.layer_features.append(layer_feature)
+
+    @pyedb_function_handler()
+    def add_profile(self, poly):  # pragma no cover
+        profile = LayerFeature(self._ipc)
+        profile.layer_name = "profile"
+        if poly:
+            if not poly.is_void:
+                profile.add_feature(poly)
+        self.profile.add_polygon(profile)
+
+    @pyedb_function_handler()
+    def add_padstack_instances(self, padstack_instances, padstack_defs):  # pragma no cover
+        top_bottom_layers = self._ipc.top_bottom_layers
+        layers = {j.layer_name: j for j in self._ipc.ecad.cad_data.cad_data_step.layer_features}
+
+        for padstack_instance in padstack_instances:
+            _, start_layer, stop_layer = padstack_instance._edb_padstackinstance.GetLayerRange()
+            for layer_name in self.layer_ranges(start_layer, stop_layer):
+                if layer_name not in layers:
+                    layer_feature = LayerFeature(self._ipc)
+                    layer_feature.layer_name = layer_name
+                    layer_feature.color = self._ipc._pedb.stackup[layer_name].color
+                    self._ipc.ecad.cad_data.cad_data_step.layer_features.append(layer_feature)
+                    layers[layer_name] = self._ipc.ecad.cad_data.cad_data_step.layer_features[-1]
+                pdef_name = (
+                    padstack_instance._pdef if padstack_instance._pdef else padstack_instance.padstack_definition
+                )
+                if pdef_name in padstack_defs:
+                    padstack_def = padstack_defs[pdef_name]
+                    comp_name = padstack_instance.GetComponent().GetName()
+                    if padstack_instance.is_pin and comp_name:
+                        component_inst = self._pedb.components.components[comp_name]
+                        layers[layer_name].add_component_padstack_instance_feature(
+                            component_inst, padstack_instance, top_bottom_layers, padstack_def
+                        )
+                    else:
+                        layers[layer_name].add_via_instance_feature(padstack_instance, padstack_def, layer_name)
+
+    @pyedb_function_handler()
+    def add_drill_layer_feature(self, via_list=None, layer_feature_name=""):  # pragma no cover
+        if via_list:
+            drill_layer_feature = LayerFeature(self._ipc)
+            drill_layer_feature.is_drill_feature = True
+            drill_layer_feature.layer_name = layer_feature_name
+            for via in via_list:
+                try:
+                    via_diameter = via.pin.GetPadstackDef().GetData().GetHoleParameters()[2][0]
+                    drill_layer_feature.add_drill_feature(via, via_diameter)
+                except:
+                    pass
+            self.layer_features.append(drill_layer_feature)
+
+    @pyedb_function_handler()
+    def write_xml(self, cad_data):  # pragma no cover
+        step = ET.SubElement(cad_data, "Step")
+        step.set("name", self._ipc.design_name)
+        for padsatck_def in list(self.padstack_defs.values()):
+            padsatck_def.write_xml(step)
+        self.profile.xml_writer(step)
+        for package in list(self.packages.values()):
+            package.write_xml(step)
+        for component in self.components:
+            component.write_xml(step)
+        for logical_net in self.logical_nets:
+            logical_net.write_xml(step)
+        for layer_feature in self.layer_features:
+            layer_feature.write_xml(step)

pyedb/ipc2581/ecad/cad_header.py

@@ -0,0 +1,33 @@
+from pyedb.generic.general_methods import ET
+from pyedb.ipc2581.ecad.spec import Spec
+
+
+class CadHeader(object):
+    """Class describing a layer stackup."""
+
+    def __init__(self):
+        self._specs = []
+        self.units = ""
+
+    @property
+    def specs(self):
+        return self._specs
+
+    def add_spec(
+        self, name="", material="", layer_type="", conductivity="", dielectric_constant="", loss_tg="", embedded=""
+    ):  # pragma no cover
+        spec = Spec()
+        spec.name = name
+        spec.material = material
+        spec.conductivity = conductivity
+        spec.dielectric_constant = dielectric_constant
+        spec.layer_type = layer_type
+        spec.loss_tangent = loss_tg
+        spec.embedded = embedded
+        self.specs.append(spec)
+
+    def write_xml(self, ecad):  # pragma no cover
+        cad_header = ET.SubElement(ecad, "CadHeader")
+        cad_header.set("units", self.units)
+        for spec in self.specs:
+            spec.write_xml(cad_header)

pyedb/ipc2581/ecad/ecad.py

@@ -0,0 +1,19 @@
+from pyedb.generic.general_methods import ET
+from pyedb.ipc2581.ecad.cad_data.cad_data import CadData
+from pyedb.ipc2581.ecad.cad_header import CadHeader
+
+
+class Ecad(object):
+    def __init__(self, ipc, edb, units):
+        self.design_name = "Design"
+        self.units = units
+        self.cad_header = CadHeader()
+        self._ipc = ipc
+        self.cad_data = CadData(self, edb, units, self._ipc)
+        self._pedb = edb
+
+    def write_xml(self, root):  # pragma no cover
+        ecad = ET.SubElement(root, "Ecad")
+        ecad.set("name", self.design_name)
+        self.cad_header.write_xml(ecad)
+        self.cad_data.write_xml(ecad)

pyedb/ipc2581/ecad/spec.py

@@ -0,0 +1,46 @@
+from pyedb.generic.general_methods import ET
+
+
+class Spec(object):
+    """Class describing a layer."""
+
+    def __init__(self):
+        self.name = ""
+        self.material = ""
+        self.layer_type = ""
+        self.conductivity = ""
+        self.dielectric_constant = ""
+        self.loss_tangent = ""
+        self.embedded = ""
+
+    def write_xml(self, ecad_header):  # pragma no cover
+        spec = ET.SubElement(ecad_header, "Spec")
+        spec.set("name", self.name)
+        material = ET.SubElement(spec, "General")
+        material.set("type", "MATERIAL")
+        material_set = ET.SubElement(material, "Property")
+        material_set.set("text", self.material)
+        layer_type = ET.SubElement(spec, "General")
+        layer_type.set("type", "OTHER")
+        layer_type.set("comment", "LAYER_TYPE")
+        layer_type_set = ET.SubElement(layer_type, "Property")
+        layer_type_set.set("text", self.layer_type)
+        conductivity = ET.SubElement(spec, "Conductor")
+        conductivity.set("type", "CONDUCTIVITY")
+        conductivity_set = ET.SubElement(conductivity, "Property")
+        conductivity_set.set("value", self.conductivity)
+        conductivity_set.set("unit", "MHO/CM")
+        dielectric = ET.SubElement(spec, "Dielectric")
+        dielectric.set("type", "DIELECTRIC_CONSTANT")
+        dielectric_set = ET.SubElement(dielectric, "Property")
+        dielectric_set.set("value", self.dielectric_constant)
+        loss_tg = ET.SubElement(spec, "Dielectric")
+        loss_tg.set("type", "LOSS_TANGENT")
+        loss_tg_set = ET.SubElement(loss_tg, "Property")
+        loss_tg_set.set("value", self.loss_tangent)
+        if self.layer_type == "CONDUCTOR":
+            embedded = ET.SubElement(spec, "General")
+            embedded.set("type", "OTHER")
+            embedded.set("comment", "LAYER_EMBEDDED_STATUS")
+            embedded_set = ET.SubElement(embedded, "Property")
+            embedded_set.set("text", self.embedded)