pyedb 0.34.3__py3-none-any.whl → 0.36.0__py3-none-any.whl

pyedb/dotnet/edb_core/edb_data/control_file.py

@@ -25,6 +25,7 @@ import os
 import re
 import subprocess
 import sys
+import xml
 
 from pyedb.edb_logger import pyedb_logger
 from pyedb.generic.general_methods import ET, env_path, env_value, is_linux
@@ -964,14 +965,14 @@ class ControlFileMeshOp:
 class ControlFileSetup:
     """Setup Class."""
 
-    def __init__(self, name):
+    def __init__(self, name, adapt_freq="1GHz", maxdelta=0.02, maxpasses=10):
         self.name = name
         self.enabled = True
         self.save_fields = False
         self.save_rad_fields = False
-        self.frequency = "1GHz"
-        self.maxpasses = 10
-        self.max_delta = 0.02
+        self.frequency = adapt_freq
+        self.maxpasses = maxpasses
+        self.max_delta = maxdelta
         self.union_polygons = True
         self.small_voids_area = 0
         self.mode_type = "IC"
@@ -1082,22 +1083,25 @@ class ControlFileSetups:
     def __init__(self):
         self.setups = []
 
-    def add_setup(self, name, frequency):
+    def add_setup(self, name, adapt_freq, maxdelta, maxpasses):
         """Add a new setup
 
         Parameters
         ----------
         name : str
-            Setup name.
-        frequency : str
+            Setup Name.
+        adapt_freq : str, optional
             Setup Frequency.
+        maxdelta : float, optional
+            Maximum Delta.
+        maxpasses : int, optional
+            Maximum Number of Passes.
 
         Returns
         -------
         :class:`pyedb.dotnet.edb_core.edb_data.control_file.ControlFileSetup`
         """
-        setup = ControlFileSetup(name)
-        setup.frequency = frequency
+        setup = ControlFileSetup(name, adapt_freq, maxdelta, maxpasses)
         self.setups.append(setup)
         return setup
 
@@ -1112,17 +1116,17 @@ class ControlFile:
 
     def __init__(self, xml_input=None, tecnhology=None, layer_map=None):
         self.stackup = ControlFileStackup()
+        self.boundaries = ControlFileBoundaries()
+        self.setups = ControlFileSetups()
         if xml_input:
             self.parse_xml(xml_input)
         if tecnhology:
             self.parse_technology(tecnhology)
         if layer_map:
             self.parse_layer_map(layer_map)
-        self.boundaries = ControlFileBoundaries()
         self.remove_holes = False
         self.remove_holes_area_minimum = 30
         self.remove_holes_units = "um"
-        self.setups = ControlFileSetups()
         self.components = ControlFileComponents()
         self.import_options = ControlFileImportOptions()
         pass
@@ -1262,6 +1266,50 @@ class ControlFile:
                                                 via.remove_unconnected = (
                                                     True if i.attrib["RemoveUnconnected"] == "true" else False
                                                 )
+            if el.tag == "Boundaries":
+                for port_el in el:
+                    if port_el.tag == "CircuitPortPt":
+                        self.boundaries.add_port(
+                            name=port_el.attrib["Name"],
+                            x1=port_el.attrib["x1"],
+                            y1=port_el.attrib["y1"],
+                            layer1=port_el.attrib["Layer1"],
+                            x2=port_el.attrib["x2"],
+                            y2=port_el.attrib["y2"],
+                            layer2=port_el.attrib["Layer2"],
+                            z0=port_el.attrib["Z0"],
+                        )
+            setups = root.find("SimulationSetups")
+            if setups:
+                hfsssetup = setups.find("HFSSSetup")
+                if hfsssetup:
+                    if "Name" in hfsssetup.attrib:
+                        name = hfsssetup.attrib["Name"]
+                    hfsssimset = hfsssetup.find("HFSSSimulationSettings")
+                    if hfsssimset:
+                        hfssadaptset = hfsssimset.find("HFSSAdaptiveSettings")
+                        if hfssadaptset:
+                            adaptset = hfssadaptset.find("AdaptiveSettings")
+                            if adaptset:
+                                singlefreqdatalist = adaptset.find("SingleFrequencyDataList")
+                                if singlefreqdatalist:
+                                    adaptfreqdata = singlefreqdatalist.find("AdaptiveFrequencyData")
+                                    if adaptfreqdata:
+                                        if isinstance(
+                                            adaptfreqdata.find("AdaptiveFrequency"), xml.etree.ElementTree.Element
+                                        ):
+                                            adapt_freq = adaptfreqdata.find("AdaptiveFrequency").text
+                                        else:
+                                            adapt_freq = "1GHz"
+                                        if isinstance(adaptfreqdata.find("MaxDelta"), xml.etree.ElementTree.Element):
+                                            maxdelta = adaptfreqdata.find("MaxDelta").text
+                                        else:
+                                            maxdelta = 0.02
+                                        if isinstance(adaptfreqdata.find("MaxPasses"), xml.etree.ElementTree.Element):
+                                            maxpasses = adaptfreqdata.find("MaxPasses").text
+                                        else:
+                                            maxpasses = 10
+                self.setups.add_setup(name, adapt_freq, maxdelta, maxpasses)
         return True
 
     def write_xml(self, xml_output):
@@ -1278,8 +1326,7 @@ class ControlFile:
         """
         control = ET.Element("{http://www.ansys.com/control}Control", attrib={"schemaVersion": "1.0"})
         self.stackup._write_xml(control)
-        if self.boundaries.ports or self.boundaries.extents:
-            self.boundaries._write_xml(control)
+        self.boundaries._write_xml(control)
         if self.remove_holes:
             hole = ET.SubElement(control, "RemoveHoles")
             hole.set("HoleAreaMinimum", str(self.remove_holes_area_minimum))

pyedb/dotnet/edb_core/edb_data/layer_data.py

@@ -60,6 +60,8 @@ class LayerEdbClass(object):
                 self.__setattr__(k, v)
             elif k == "roughness":
                 self.properties = {"roughness": v}
+            elif k == "etching":
+                self.properties = {"etching": v}
             else:
                 self._pedb.logger.error(f"{k} is not a valid layer attribute")
 
@@ -792,6 +794,15 @@ class StackupLayerEdbClass(LayerEdbClass):
         data["thickness"] = self._edb_object.GetThicknessValue().ToString()
         data["color"] = self.color
 
+        data["etching"] = {
+            "factor": self._edb_layer.GetEtchFactor().ToString(),
+            "enabled": self._edb_layer.IsEtchFactorEnabled(),
+        }
+        if self._pedb.edbversion >= "2024.2":
+            etch_power_ground_nets = int(self._edb_layer.GetEtchNetClass())
+            etch_power_ground_nets = False if etch_power_ground_nets else True
+            data["etching"]["etch_power_ground_nets"] = etch_power_ground_nets
+
         roughness = {}
         for region in ["top", "bottom", "side"]:
             temp = {}
@@ -851,5 +862,14 @@ class StackupLayerEdbClass(LayerEdbClass):
                     getattr(self._pedb._edb.Cell.RoughnessModel.Region, region.capitalize()), r_model
                 )
             self._pedb.stackup._set_layout_stackup(layer_clone, "change_attribute")
-
-        layer_clone.SetRoughnessEnabled(True)
+        etching = params.get("etching")
+        if etching:
+            layer_clone = self._edb_layer
+            layer_clone.SetEtchFactorEnabled(etching["enabled"])
+            layer_clone.SetEtchFactor(self._pedb.stackup._edb_value(float(etching["factor"])))
+            if self._pedb.edbversion >= "2024.2":
+                if etching["etch_power_ground_nets"]:
+                    layer_clone.SetEtchNetClass(self._pedb._edb.Cell.EtchNetClass.NoEtchPowerGroundNets)
+                else:
+                    layer_clone.SetEtchNetClass(self._pedb._edb.Cell.EtchNetClass.EtchAllNets)
+            self._pedb.stackup._set_layout_stackup(layer_clone, "change_attribute")

pyedb/dotnet/edb_core/edb_data/padstacks_data.py

@@ -22,7 +22,6 @@
 
 from collections import OrderedDict
 import math
-import re
 import warnings
 
 from pyedb.dotnet.clr_module import String
@@ -1248,68 +1247,30 @@ class EDBPadstackInstance(Primitive):
 
         return self._pedb.create_port(terminal, ref_terminal, is_circuit_port)
 
-    @property
-    def _em_properties(self):
-        """Get EM properties."""
-        default = (
-            r"$begin 'EM properties'\n"
-            r"\tType('Mesh')\n"
-            r"\tDataId='EM properties1'\n"
-            r"\t$begin 'Properties'\n"
-            r"\t\tGeneral=''\n"
-            r"\t\tModeled='true'\n"
-            r"\t\tUnion='true'\n"
-            r"\t\t'Use Precedence'='false'\n"
-            r"\t\t'Precedence Value'='1'\n"
-            r"\t\tPlanarEM=''\n"
-            r"\t\tRefined='true'\n"
-            r"\t\tRefineFactor='1'\n"
-            r"\t\tNoEdgeMesh='false'\n"
-            r"\t\tHFSS=''\n"
-            r"\t\t'Solve Inside'='false'\n"
-            r"\t\tSIwave=''\n"
-            r"\t\t'DCIR Equipotential Region'='false'\n"
-            r"\t$end 'Properties'\n"
-            r"$end 'EM properties'\n"
-        )
-
-        pid = self._pedb.edb_api.ProductId.Designer
-        _, p = self._edb_padstackinstance.GetProductProperty(pid, 18, "")
-        if p:
-            return p
-        else:
-            return default
-
-    @_em_properties.setter
-    def _em_properties(self, em_prop):
-        """Set EM properties"""
-        pid = self._pedb.edb_api.ProductId.Designer
-        self._edb_padstackinstance.SetProductProperty(pid, 18, em_prop)
-
-    @property
-    def dcir_equipotential_region(self):
-        """Check whether dcir equipotential region is enabled.
+    def _set_equipotential(self):
+        """Workaround solution. Remove when EDBAPI bug is fixed for dcir_equipotential_region."""
+        pad = self.definition.pad_by_layer[self.start_layer]
+        if pad.shape.lower() == "circle":
+            ra = self._pedb.edb_value(pad.parameters_values[0] / 2)
+            pos = self.position
+            prim = self._pedb.modeler.create_circle(pad.layer_name, pos[0], pos[1], ra, self.net_name)
+        elif pad.shape.lower() == "rectangle":
+            width, height = pad.parameters_values
+            prim = self._pedb.modeler.create_rectangle(
+                pad.layer_name,
+                self.net_name,
+                width=width,
+                height=height,
+                representation_type="CenterWidthHeight",
+                center_point=self.position,
+                rotation=self.component.rotation,
+            )
 
-        Returns
-        -------
-        bool
-        """
-        pattern = r"'DCIR Equipotential Region'='([^']+)'"
-        em_pp = self._em_properties
-        result = re.search(pattern, em_pp).group(1)
-        if result == "true":
-            return True
+        elif pad.polygon_data:
+            prim = self._pedb.modeler.create_polygon(pad.polygon_data, self.start_layer, net_name=self.net_name)
         else:
-            return False
-
-    @dcir_equipotential_region.setter
-    def dcir_equipotential_region(self, value):
-        """Set dcir equipotential region."""
-        pp = r"'DCIR Equipotential Region'='true'" if value else r"'DCIR Equipotential Region'='false'"
-        em_pp = self._em_properties
-        pattern = r"'DCIR Equipotential Region'='([^']+)'"
-        new_em_pp = re.sub(pattern, pp, em_pp)
-        self._em_properties = new_em_pp
+            return
+        prim.dcir_equipotential_region = True
 
     @property
     def object_instance(self):
@@ -1577,7 +1538,6 @@ class EDBPadstackInstance(Primitive):
         str
             Name of the starting layer.
         """
-        layer = self._pedb.edb_api.cell.layer("", self._pedb.edb_api.cell.layer_type.SignalLayer)
         _, start_layer, stop_layer = self._edb_object.GetLayerRange()
 
         if start_layer:
@@ -1599,7 +1559,6 @@ class EDBPadstackInstance(Primitive):
         str
             Name of the stopping layer.
         """
-        layer = self._pedb.edb_api.cell.layer("", self._pedb.edb_api.cell.layer_type.SignalLayer)
         _, start_layer, stop_layer = self._edb_padstackinstance.GetLayerRange()
 
         if stop_layer:
@@ -1705,7 +1664,6 @@ class EDBPadstackInstance(Primitive):
         float
             Rotatation value for the padstack instance.
         """
-        point_data = self._pedb.edb_api.geometry.point_data(self._pedb.edb_value(0.0), self._pedb.edb_value(0.0))
         out = self._edb_padstackinstance.GetPositionAndRotationValue()
 
         if out[0]:

pyedb/dotnet/edb_core/padstack.py

@@ -26,7 +26,9 @@ This module contains the `EdbPadstacks` class.
 import math
 import warnings
 
+import numpy as np
 import rtree
+from scipy.spatial import ConvexHull
 
 from pyedb.dotnet.clr_module import Array
 from pyedb.dotnet.edb_core.edb_data.padstacks_data import (
@@ -1553,7 +1555,7 @@ class EdbPadstacks(object):
             padstack_instances_index.insert(inst.id, inst.position)
         return padstack_instances_index
 
-    def get_padstack_instances_intersecting_bounding_box(self, bounding_box, nets=None):
+    def get_padstack_instances_id_intersecting_polygon(self, points, nets=None, padstack_instances_index=None):
         """Returns the list of padstack instances ID intersecting a given bounding box and nets.
 
         Parameters
@@ -1563,6 +1565,38 @@ class EdbPadstacks(object):
         nets : str or list, optional
             net name of list of nets name applying filtering on padstack instances selection. If ``None`` is provided
             all instances are included in the index. Default value is ``None``.
+        padstack_instances_index : optional, Rtree object.
+            Can be provided optionally to prevent computing padstack instances Rtree index again.
+
+        Returns
+        -------
+        List of padstack instances ID intersecting the bounding box.
+        """
+        if not points:
+            raise Exception("No points defining polygon was provided")
+        if not padstack_instances_index:
+            padstack_instances_index = {}
+            for inst in self.instances:
+                padstack_instances_index[inst.id] = inst.position
+        _x = [pt[0] for pt in points]
+        _y = [pt[1] for pt in points]
+        points = [_x, _y]
+        return [
+            ind for ind, pt in padstack_instances_index.items() if GeometryOperators.is_point_in_polygon(pt, points)
+        ]
+
+    def get_padstack_instances_intersecting_bounding_box(self, bounding_box, nets=None, padstack_instances_index=None):
+        """Returns the list of padstack instances ID intersecting a given bounding box and nets.
+
+        Parameters
+        ----------
+        bounding_box : tuple or list.
+            bounding box, [x1, y1, x2, y2]
+        nets : str or list, optional
+            net name of list of nets name applying filtering on padstack instances selection. If ``None`` is provided
+            all instances are included in the index. Default value is ``None``.
+        padstack_instances_index : optional, Rtree object.
+            Can be provided optionally to prevent computing padstack instances Rtree index again.
 
         Returns
         -------
@@ -1570,15 +1604,123 @@ class EdbPadstacks(object):
         """
         if not bounding_box:
             raise Exception("No bounding box was provided")
-        index = self.get_padstack_instances_rtree_index(nets=nets)
+        if not padstack_instances_index:
+            index = self.get_padstack_instances_rtree_index(nets=nets)
+        else:
+            index = padstack_instances_index
         if not len(bounding_box) == 4:
             raise Exception("The bounding box length must be equal to 4")
         if isinstance(bounding_box, list):
             bounding_box = tuple(bounding_box)
         return list(index.intersection(bounding_box))
 
+    def merge_via(self, contour_boxes, net_filter=None, start_layer=None, stop_layer=None):
+        """Evaluate padstack instances included on the provided point list and replace all by single instance.
+
+        Parameters
+        ----------
+        contour_boxes : List[List[List[float, float]]]
+            Nested list of polygon with points [x,y].
+        net_filter : optional
+            List[str: net_name] apply a net filter, nets included in the filter are excluded from the via merge.
+        start_layer : optional, str
+            Padstack instance start layer, if `None` the top layer is selected.
+        stop_layer : optional, str
+            Padstack instance stop layer, if `None` the bottom layer is selected.
+
+        Return
+        ------
+        List[str], list of created padstack instances ID.
+
+        """
+        merged_via_ids = []
+        if not contour_boxes:
+            raise Exception("No contour box provided, you need to pass a nested list as argument.")
+
+        instances_index = {}
+        for id, inst in self.instances.items():
+            instances_index[id] = inst.position
+        for contour_box in contour_boxes:
+            all_instances = self.instances
+            instances = self.get_padstack_instances_id_intersecting_polygon(
+                points=contour_box, padstack_instances_index=instances_index
+            )
+            if not instances:
+                raise Exception(f"No padstack instances found inside {contour_box}")
+            else:
+                if net_filter:
+                    # instances = [id for id in instances if not self.instances[id].net_name in net_filter]
+                    instances = [id for id in instances if all_instances[id].net_name not in net_filter]
+                # filter instances by start and stop layer
+                if start_layer:
+                    if start_layer not in self._pedb.stackup.layers.keys():
+                        raise Exception(f"{start_layer} not exist")
+                    else:
+                        instances = [id for id in instances if all_instances[id].start_layer == start_layer]
+                if stop_layer:
+                    if stop_layer not in self._pedb.stackup.layers.keys():
+                        raise Exception(f"{stop_layer} not exist")
+                    else:
+                        instances = [id for id in instances if all_instances[id].stop_layer == stop_layer]
+                if not instances:
+                    raise Exception(
+                        f"No padstack instances found inside {contour_box} between {start_layer} and {stop_layer}"
+                    )
+
+                if not start_layer:
+                    start_layer = list(self._pedb.stackup.layers.values())[0].name
+                if not stop_layer:
+                    stop_layer = list(self._pedb.stackup.layers.values())[-1].name
+
+                net = self.instances[instances[0]].net_name
+                x_values = []
+                y_values = []
+                for inst in instances:
+                    pos = instances_index[inst]
+                    x_values.append(pos[0])
+                    y_values.append(pos[1])
+                x_values = list(set(x_values))
+                y_values = list(set(y_values))
+                if len(x_values) == 1 or len(y_values) == 1:
+                    create_instances = self.merge_via_along_lines(
+                        net_name=net, padstack_instances_id=instances, minimum_via_number=2
+                    )
+                    merged_via_ids.extend(create_instances)
+                else:
+                    instances_pts = np.array([instances_index[id] for id in instances])
+                    convex_hull_contour = ConvexHull(instances_pts)
+                    contour_points = list(instances_pts[convex_hull_contour.vertices])
+                    layer = list(self._pedb.stackup.layers.values())[0].name
+                    polygon = self._pedb.modeler.create_polygon(main_shape=contour_points, layer_name=layer)
+                    polygon_data = polygon.polygon_data
+                    polygon.delete()
+                    new_padstack_def = generate_unique_name(self.instances[instances[0]].definition.name)
+                    if not self.create(
+                        padstackname=new_padstack_def,
+                        pad_shape="Polygon",
+                        antipad_shape="Polygon",
+                        pad_polygon=polygon_data,
+                        antipad_polygon=polygon_data,
+                        polygon_hole=polygon_data,
+                        start_layer=start_layer,
+                        stop_layer=stop_layer,
+                    ):
+                        raise Exception(f"Failed to create padstack definition {new_padstack_def}")
+                    merged_instance = self.place(position=[0, 0], definition_name=new_padstack_def, net_name=net)
+                    merged_instance.start_layer = start_layer
+                    merged_instance.stop_layer = stop_layer
+
+                    merged_via_ids.append(merged_instance.id)
+                    _ = [all_instances[id].delete() for id in instances]
+        return merged_via_ids
+
     def merge_via_along_lines(
-        self, net_name="GND", distance_threshold=5e-3, minimum_via_number=6, selected_angles=None
+        self,
+        net_name="GND",
+        distance_threshold=5e-3,
+        minimum_via_number=6,
+        selected_angles=None,
+        padstack_instances_id=None,
     ):
         """Replace padstack instances along lines into a single polygon.
 
@@ -1602,11 +1744,15 @@ class EdbPadstacks(object):
             Specify angle in degrees to detected, for instance [0, 180] is only detecting horizontal and vertical lines.
             Other values can be assigned like 45 degrees. When `None` is provided all lines are detected. Default value
             is `None`.
+        padstack_instances_id : List[int]
+         List of padstack instances ID's to include. If `None`, the algorithm will scan all padstack instances belonging
+         to the specified net. Default value is `None`.
+
 
         Returns
         -------
         bool
-            ``True`` when succeeded ``False`` when failed. <
+            List[int], list of created padstack instances id.
 
         """
         _def = list(
@@ -1615,12 +1761,16 @@ class EdbPadstacks(object):
         if not _def:
             self._logger.error(f"No padstack definition found for net {net_name}")
             return False
+        instances_created = []
         _instances_to_delete = []
         padstack_instances = []
-        for pdstk_def in _def:
-            padstack_instances.append(
-                [inst for inst in self.definitions[pdstk_def].instances if inst.net_name == net_name]
-            )
+        if padstack_instances_id:
+            padstack_instances = [[self.instances[id] for id in padstack_instances_id]]
+        else:
+            for pdstk_def in _def:
+                padstack_instances.append(
+                    [inst for inst in self.definitions[pdstk_def].instances if inst.net_name == net_name]
+                )
         for pdstk_series in padstack_instances:
             instances_location = [inst.position for inst in pdstk_series]
             lines, line_indexes = GeometryOperators.find_points_along_lines(
@@ -1652,8 +1802,65 @@ class EdbPadstacks(object):
                     polygon_hole=polygon_data,
                 ):
                     self._logger.error(f"Failed to create padstack definition {new_padstack_def}")
-                if not self.place(position=[0, 0], definition_name=new_padstack_def, net_name=net_name):
+                new_instance = self.place(position=[0, 0], definition_name=new_padstack_def, net_name=net_name)
+                if not new_instance:
                     self._logger.error(f"Failed to place padstack instance {new_padstack_def}")
+                else:
+                    instances_created.append(new_instance.id)
             for inst in _instances_to_delete:
                 inst.delete()
-        return True
+        return instances_created
+
+    def reduce_via_in_bounding_box(self, bounding_box, x_samples, y_samples, nets=None):
+        """
+        reduce the number of vias intersecting bounding box and nets by x and y samples.
+
+        Parameters
+        ----------
+        bounding_box : tuple or list.
+            bounding box, [x1, y1, x2, y2]
+        x_samples : int
+        y_samples : int
+        nets : str or list, optional
+            net name of list of nets name applying filtering on padstack instances selection. If ``None`` is provided
+            all instances are included in the index. Default value is ``None``.
+
+        Returns
+        -------
+        bool
+            ``True`` when succeeded ``False`` when failed. <
+        """
+
+        padstacks_inbox = self.get_padstack_instances_intersecting_bounding_box(bounding_box, nets)
+        if not padstacks_inbox:
+            self._logger.info("no padstack in bounding box")
+            return False
+        else:
+            if len(padstacks_inbox) <= (x_samples * y_samples):
+                self._logger.info(f"more samples {x_samples * y_samples} than existing {len(padstacks_inbox)}")
+                return False
+            else:
+                # extract ids and positions
+                vias = {item: self.instances[item].position for item in padstacks_inbox}
+                ids, positions = zip(*vias.items())
+                pt_x, pt_y = zip(*positions)
+
+                # meshgrid
+                _x_min, _x_max = min(pt_x), max(pt_x)
+                _y_min, _y_max = min(pt_y), max(pt_y)
+
+                x_grid, y_grid = np.meshgrid(
+                    np.linspace(_x_min, _x_max, x_samples), np.linspace(_y_min, _y_max, y_samples)
+                )
+
+                # mapping to meshgrid
+                to_keep = {
+                    ids[np.argmin(np.square(_x - pt_x) + np.square(_y - pt_y))]
+                    for _x, _y in zip(x_grid.ravel(), y_grid.ravel())
+                }
+
+                for item in padstacks_inbox:
+                    if item not in to_keep:
+                        self.instances[item].delete()
+
+                return True

pyedb/dotnet/edb_core/siwave.py

@@ -1242,8 +1242,7 @@ class EdbSiwave(object):
         )
 
         if edb_pingroup.IsNull():  # pragma: no cover
-            self._logger.error(f"Failed to create pin group {group_name}.")
-            return False
+            raise RuntimeError(f"Failed to create pin group {group_name}.")
         else:
             names = [i for i in pins if i.GetNet().GetName()]
             edb_pingroup.SetNet(names[0].GetNet())

pyedb/generic/process.py

@@ -1,7 +1,7 @@
 import os.path
 import subprocess
 
-from pyedb.generic.general_methods import env_path, is_linux
+from pyedb.generic.general_methods import env_path, is_linux, is_windows
 
 
 class SiwaveSolve(object):
@@ -144,19 +144,19 @@ class SiwaveSolve(object):
             f.write("oDoc.ScrExport3DModel('{}', q3d_filename)\n".format(format_3d))
             f.write("oDoc.ScrCloseProject()\n")
             f.write("oApp.Quit()\n")
-        if is_linux:
-            _exe = '"' + os.path.join(self.installer_path, "siwave") + '"'
-        else:
-            _exe = '"' + os.path.join(self.installer_path, "siwave.exe") + '"'
+        _exe = os.path.join(self.installer_path, "siwave")
+        if is_windows:
+            _exe += ".exe"
         command = [_exe]
         if hidden:
             command.append("-embedding")
-        command.append("-RunScriptAndExit")
-        command.append(scriptname)
+        command += ["-RunScriptAndExit", scriptname]
         print(command)
-        os.system(" ".join(command))
-        # p1 = subprocess.call(" ".join(command))
-        # p1.wait()
+        try:
+            result = subprocess.run(command, check=True, capture_output=True)
+            print(result.stdout.decode())
+        except subprocess.CalledProcessError as e:
+            print(f"Error occurred: {e.stderr.decode()}")
         return os.path.join(output_folder, aedt_file_name)
 
     def export_dc_report(