pyedb 0.44.0__py3-none-any.whl → 0.46.0__py3-none-any.whl

pyedb/configuration/cfg_setup.py

@@ -32,6 +32,59 @@ class CfgSetup:
     """
 
     class Common:
+        class Grpc:
+            def __init__(self, parent):
+                self.parent = parent
+
+            def apply_freq_sweep(self, edb_setup):
+                for i in self.parent.parent.freq_sweep:
+                    f_set = []
+                    freq_string = []
+                    for f in i.get("frequencies", []):
+                        if isinstance(f, dict):
+                            increment = f.get("increment", f.get("points", f.get("samples", f.get("step"))))
+                            f_set.append([f["distribution"], f["start"], f["stop"], increment])
+                        else:
+                            freq_string.append(f)
+                    discrete_sweep = True
+                    if i["type"] == "interpolation":
+                        discrete_sweep = False
+                    if freq_string:
+                        for _sweep in freq_string:
+                            _sw = _sweep.split(" ")
+                            edb_setup.add_sweep(
+                                name=i["name"],
+                                distribution=_sw[0],
+                                start_freq=_sw[1],
+                                stop_freq=_sw[2],
+                                step=_sw[3],
+                                discrete=discrete_sweep,
+                            )
+                    else:
+                        edb_setup.add_sweep(i["name"], frequency_set=f_set, discrete=discrete_sweep)
+
+        class DotNet(Grpc):
+            def __init__(self, parent):
+                super().__init__(parent)
+
+            @staticmethod
+            def set_frequency_string(sweep, freq_string):
+                sweep.frequency_string = freq_string
+
+            def apply_freq_sweep(self, edb_setup):
+                for i in self.parent.parent.freq_sweep:
+                    f_set = []
+                    freq_string = []
+                    for f in i.get("frequencies", []):
+                        if isinstance(f, dict):
+                            increment = f.get("increment", f.get("points", f.get("samples", f.get("step"))))
+                            f_set.append([f["distribution"], f["start"], f["stop"], increment])
+                        else:
+                            freq_string.append(f)
+                    sweep = edb_setup.add_sweep(i["name"], frequency_set=f_set, sweep_type=i["type"])
+                    if len(freq_string) > 0:
+                        self.parent.api.set_frequency_string(sweep, freq_string)
+
         @property
         def pyedb_obj(self):
             return self.parent.pyedb_obj
@@ -39,24 +92,17 @@ class CfgSetup:
         def __init__(self, parent):
             self.parent = parent
             self.pedb = parent.pedb
+            if self.pedb.grpc:
+                self.api = self.Grpc(self)
+            else:
+                self.api = self.DotNet(self)
 
         def _retrieve_parameters_from_edb_common(self):
             self.parent.name = self.pyedb_obj.name
             self.parent.type = self.pyedb_obj.type
 
         def _apply_freq_sweep(self, edb_setup):
-            for i in self.parent.freq_sweep:
-                f_set = []
-                freq_string = []
-                for f in i.get("frequencies", []):
-                    if isinstance(f, dict):
-                        increment = f.get("increment", f.get("points", f.get("samples", f.get("step"))))
-                        f_set.append([f["distribution"], f["start"], f["stop"], increment])
-                    else:
-                        freq_string.append(f)
-                sweep = edb_setup.add_sweep(i["name"], frequency_set=f_set, sweep_type=i["type"])
-                if len(freq_string) > 0:
-                    sweep.frequency_string = freq_string
+            self.api.apply_freq_sweep(edb_setup)
 
     class Grpc(Common):
         def __init__(self, parent):
@@ -149,7 +195,7 @@ class CfgSIwaveDCSetup(CfgSetup):
                 name=self.parent.name, dc_slider_position=self.parent.dc_slider_position
             )
             edb_setup.settings.dc.dc_slider_pos = self.parent.dc_slider_position
-            edb_setup.settings.export_dc_thermal_data = self.parent.dc_ir_settings["export_dc_thermal_data"]
+            edb_setup.settings.export_dc_thermal_data = self.parent.dc_ir_settings.get("export_dc_thermal_data", False)
 
         def retrieve_parameters_from_edb(self):
             self._retrieve_parameters_from_edb_common()
@@ -168,7 +214,7 @@ class CfgSIwaveDCSetup(CfgSetup):
             )
             edb_setup.dc_settings.dc_slider_position = self.parent.dc_slider_position
             dc_ir_settings = self.parent.dc_ir_settings
-            edb_setup.dc_ir_settings.export_dc_thermal_data = dc_ir_settings["export_dc_thermal_data"]
+            edb_setup.dc_ir_settings.export_dc_thermal_data = dc_ir_settings.get("export_dc_thermal_data", False)
 
     def __init__(self, pedb, pyedb_obj, **kwargs):
         super().__init__(pedb, pyedb_obj, **kwargs)
@@ -216,8 +262,12 @@ class CfgHFSSSetup(CfgSetup):
             self.parent.max_num_passes = single_frequency_adaptive_solution.max_passes
             self.parent.max_mag_delta_s = float(single_frequency_adaptive_solution.max_delta)
             self.parent.freq_sweep = []
-            for sw in self.pyedb_obj.sweep_data:
-                self.parent.freq_sweep.append({"name": sw.name, "type": sw.type, "frequencies": sw.frequency_string})
+            setup_sweeps = self.sort_sweep_data(self.pyedb_obj.sweep_data)
+            for setup_name, sweeps in setup_sweeps.items():
+                sw_name = sweeps[0].name
+                sw_type = sweeps[0].type.name.lower().split("_")[0]
+                freq_strings = [f.frequency_string for f in sweeps]
+                self.parent.freq_sweep.append({"name": sw_name, "type": sw_type, "frequencies": freq_strings})
 
             self.parent.mesh_operations = []
             from ansys.edb.core.simulation_setup.mesh_operation import (
@@ -241,6 +291,17 @@ class CfgHFSSSetup(CfgSetup):
                     }
                 )
 
+        @staticmethod
+        def sort_sweep_data(sweep_data):
+            """grpc sweep data contains all sweeps for each setup, we need to sort thwm by setup"""
+            setups = {}
+            for sweep in sweep_data:
+                if sweep.name not in setups:
+                    setups[sweep.name] = [sweep]
+                else:
+                    setups[sweep.name].append(sweep)
+            return setups
+
     class DotNet(Grpc):
         def __init__(self, parent):
             super().__init__(parent)

pyedb/configuration/configuration.py

@@ -205,6 +205,8 @@ class Configuration:
                 self.parent.cfg_data.components.retrieve_parameters_from_edb()
                 components = []
                 for i in self.parent.cfg_data.components.components:
+                    if i.type == "io":
+                        components.append(i.get_attributes())
                     components.append(i.get_attributes())
 
                 if kwargs.get("components", False):
@@ -306,6 +308,14 @@ class Configuration:
             file_path = file_path if isinstance(file_path, Path) else Path(file_path)
             file_path = file_path.with_suffix(".json") if file_path.suffix == "" else file_path
 
+            for comp in data["components"]:
+                for key, value in comp.items():
+                    try:
+                        json.dumps(value)
+                        print(f"Key '{key}' is serializable.")
+                    except TypeError as e:
+                        print(f"Key '{key}' failed: {e}")
+
             with open(file_path, "w") as f:
                 if file_path.suffix == ".json":
                     json.dump(data, f, ensure_ascii=False, indent=4)
@@ -472,9 +482,6 @@ class Configuration:
         # Configure package definitions
         self.cfg_data.package_definitions.apply()
 
-        # Configure operations
-        self.cfg_data.operations.apply()
-
         # Modeler
         self.cfg_data.modeler.apply()
 
@@ -484,6 +491,9 @@ class Configuration:
         # Configure probes
         self.cfg_data.probes.apply()
 
+        # Configure operations
+        self.cfg_data.operations.apply()
+
         return True
 
     def _load_stackup(self):

pyedb/dotnet/database/cell/primitive/path.py

@@ -341,6 +341,18 @@ class Path(Primitive):
             polygon_data = self._edb.geometry.polygon_data.dotnetobj(convert_py_list_to_net_list(points), False)
             self._edb_object.SetCenterLine(polygon_data)
 
+    def get_center_line_polygon_data(self):
+        """Gets center lines of the path as a PolygonData object."""
+        edb_object = self._edb_object.GetCenterLine()
+        return self._pedb.pedb_class.database.geometry.polygon_data.PolygonData(self._pedb, edb_object=edb_object)
+
+    def set_center_line_polygon_data(self, polygon_data):
+        """Sets center lines of the path from a PolygonData object."""
+        if not self._edb_object.SetCenterLine(polygon_data._edb_object):
+            raise ValueError
+        else:
+            return True
+
     @property
     def corner_style(self):
         """:class:`PathCornerType`: Path's corner style."""

pyedb/dotnet/database/geometry/point_data.py

@@ -35,3 +35,29 @@ class PointData:
                 self._pedb.edb_value(x),
                 self._pedb.edb_value(y),
             )
+
+    @property
+    def x(self):
+        """X value of point."""
+        return self._edb_object.X.ToString()
+
+    @x.setter
+    def x(self, value):
+        self._edb_object.X = self._pedb.edb_value(value)
+
+    @property
+    def x_evaluated(self):
+        return self._edb_object.X.ToDouble()
+
+    @property
+    def y(self):
+        """Y value of point."""
+        return self._edb_object.Y.ToString()
+
+    @y.setter
+    def y(self, value):
+        self._edb_object.Y = self._pedb.edb_value(value)
+
+    @property
+    def y_evaluated(self):
+        return self._edb_object.Y.ToDouble()

pyedb/dotnet/database/geometry/polygon_data.py

@@ -135,3 +135,12 @@ class PolygonData:
     def point_in_polygon(self, x: Union[str, float], y: Union[str, float]) -> bool:
         """Determines whether a point is inside the polygon."""
         return self._edb_object.PointInPolygon(self._pedb.point_data(x, y))
+
+    def get_point(self, index):
+        """Gets the point at the index as a PointData object."""
+        edb_object = self._edb_object.GetPoint(index)
+        return self._pedb.pedb_class.database.geometry.point_data.PointData(self._pedb, edb_object)
+
+    def set_point(self, index, point_data):
+        """Sets the point at the index from a PointData object."""
+        self._edb_object.SetPoint(index, point_data)

pyedb/dotnet/database/nets.py

@@ -308,11 +308,21 @@ class EdbNets(CommonNets):
                 val_value = cmp.rlc_values
                 if refdes in exception_list:
                     pass
-                elif val_type == "Inductor" and val_value[1] < inductor_below:
+                elif (
+                    val_type == "Inductor"
+                    and self._pedb.edb_value(val_value[1]).ToDouble() <= self._pedb.edb_value(inductor_below).ToDouble()
+                ):
                     pass
-                elif val_type == "Resistor" and val_value[0] < resistor_below:
+                elif (
+                    val_type == "Resistor"
+                    and self._pedb.edb_value(val_value[0]).ToDouble() <= self._pedb.edb_value(resistor_below).ToDouble()
+                ):
                     pass
-                elif val_type == "Capacitor" and val_value[2] > capacitor_above:
+                elif (
+                    val_type == "Capacitor"
+                    and self._pedb.edb_value(val_value[2]).ToDouble()
+                    >= self._pedb.edb_value(capacitor_above).ToDouble()
+                ):
                     pass
                 else:
                     continue

pyedb/dotnet/edb.py

@@ -41,13 +41,13 @@ from zipfile import ZipFile as zpf
 import rtree
 
 from pyedb.configuration.configuration import Configuration
+import pyedb.dotnet
 from pyedb.dotnet.database.Variables import decompose_variable_value
 from pyedb.dotnet.database.cell.layout import Layout
 from pyedb.dotnet.database.cell.terminal.terminal import Terminal
 from pyedb.dotnet.database.components import Components
 import pyedb.dotnet.database.dotnet.database
 from pyedb.dotnet.database.dotnet.database import Database
-from pyedb.dotnet.database.edb_data.control_file import convert_technology_file
 from pyedb.dotnet.database.edb_data.design_options import EdbDesignOptions
 from pyedb.dotnet.database.edb_data.edbvalue import EdbValue
 from pyedb.dotnet.database.edb_data.ports import (
@@ -134,9 +134,17 @@ class Edb(Database):
         Reference to the AEDT project object.
     student_version : bool, optional
         Whether to open the AEDT student version. The default is ``False.``
+    control_file : str, optional
+            Path to the XML file. The default is ``None``, in which case an attempt is made to find
+            the XML file in the same directory as the board file. To succeed, the XML file and board file
+            must have the same name. Only the extension differs.
+    map_file : str, optional
+        Layer map .map file.
     technology_file : str, optional
         Full path to technology file to be converted to xml before importing or xml.
         Supported by GDS format only.
+    layer_filter:str,optional
+        Layer filter .txt file.
 
     Examples
     --------
@@ -182,7 +190,10 @@ class Edb(Database):
         oproject=None,
         student_version: bool = False,
         use_ppe: bool = False,
+        control_file: str = None,
+        map_file: str = None,
         technology_file: str = None,
+        layer_filter: str = None,
         remove_existing_aedt: bool = False,
     ):
         if isinstance(edbpath, Path):
@@ -232,27 +243,35 @@ class Edb(Database):
                 zipped_file.extractall(edbpath[:-4])
                 self.logger.info("ODB++ unzipped successfully.")
             zipped_file.close()
-            control_file = None
-            if technology_file:
-                if os.path.splitext(technology_file)[1] == ".xml":
-                    control_file = technology_file
-                else:
-                    control_file = convert_technology_file(technology_file, edbversion=edbversion)
             self.logger.info("Translating ODB++ to EDB...")
-            self.import_layout_file(edbpath[:-4], working_dir, use_ppe=use_ppe, control_file=control_file)
+            if not self.import_layout_file(
+                edbpath[:-4],
+                working_dir,
+                use_ppe=use_ppe,
+                control_file=control_file,
+                tech_file=technology_file,
+                layer_filter=layer_filter,
+                map_file=map_file,
+            ):
+                raise AttributeError("Translation was unsuccessful")
+                return False
             if settings.enable_local_log_file and self.log_name:
                 self._logger.add_file_logger(self.log_name, "Edb")
             self.logger.info("EDB %s was created correctly from %s file.", self.edbpath, edbpath)
         elif edbpath[-3:] in ["brd", "mcm", "sip", "gds", "xml", "dxf", "tgz", "anf"]:
             self.edbpath = edbpath[:-4] + ".aedb"
             working_dir = os.path.dirname(edbpath)
-            control_file = None
-            if technology_file:
-                if os.path.splitext(technology_file)[1] == ".xml":
-                    control_file = technology_file
-                else:
-                    control_file = convert_technology_file(technology_file, edbversion=edbversion)
-            self.import_layout_file(edbpath, working_dir, use_ppe=use_ppe, control_file=control_file)
+            if not self.import_layout_file(
+                edbpath,
+                working_dir,
+                use_ppe=use_ppe,
+                control_file=control_file,
+                tech_file=technology_file,
+                layer_filter=layer_filter,
+                map_file=map_file,
+            ):
+                raise AttributeError("Translation was unsuccessful")
+                return False
             if settings.enable_local_log_file and self.log_name:
                 self._logger.add_file_logger(self.log_name, "Edb")
             self.logger.info("EDB %s was created correctly from %s file.", self.edbpath, edbpath[-2:])
@@ -371,6 +390,11 @@ class Edb(Database):
         self._stackup2 = self._stackup
         self._materials = Materials(self)
 
+    @property
+    def pedb_class(self):
+        if not self.grpc:
+            return pyedb.dotnet
+
     @property
     def grpc(self):
         """grpc flag."""
@@ -584,7 +608,7 @@ class Edb(Database):
         #     self.standalone = False
 
         self.run_as_standalone(self.standalone)
-        self.create(self.edbpath)
+        self._db = self.create(self.edbpath)
         if not self.active_db:
             self.logger.warning("Error creating the database.")
             self._active_cell = None
@@ -733,8 +757,7 @@ class Edb(Database):
             cmd_translator.append('-t="{}"'.format(tech_file))
         if layer_filter:
             cmd_translator.append('-f="{}"'.format(layer_filter))
-        p = subprocess.Popen(cmd_translator)
-        p.wait()
+        subprocess.run(cmd_translator)
         if not os.path.exists(os.path.join(working_dir, aedb_name)):
             self.logger.error("Translator failed to translate.")
             return False

pyedb/generic/design_types.py

@@ -33,6 +33,7 @@ def Edb(
     use_ppe=False,
     technology_file=None,
     grpc=False,
+    control_file=None,
 ):
     """Provides the EDB application interface.
 
@@ -127,6 +128,7 @@ def Edb(
         student_version=student_version,
         use_ppe=use_ppe,
         technology_file=technology_file,
+        control_file=control_file,
     )
 
 

pyedb/grpc/database/components.py

@@ -178,8 +178,7 @@ class Components(object):
     @property
     def nport_comp_definition(self):
         """Retrieve Nport component definition list."""
-        m = "Ansys.Ansoft.Edb.Definition.NPortComponentModel"
-        return {name: l for name, l in self.definitions.items() if m in [i for i in l.model]}
+        return {name: l for name, l in self.definitions.items() if l.reference_file}
 
     def import_definition(self, file_path):
         """Import component definition from json file.

pyedb/grpc/database/definition/component_def.py

@@ -230,4 +230,4 @@ class ComponentDef(GrpcComponentDef):
         if pin_order:
             old = {i.name: i for i in self.component_pins}
             temp = [old[str(i)] for i in pin_order]
-            self.component_pins = temp
+            self.reorder_pins(temp)

pyedb/grpc/database/hfss.py

@@ -1240,6 +1240,12 @@ class Hfss(object):
         from ansys.edb.core.simulation_setup.hfss_simulation_setup import (
             HfssSimulationSetup as GrpcHfssSimulationSetup,
         )
+        from ansys.edb.core.simulation_setup.simulation_setup import (
+            Distribution as GrpcDistribution,
+        )
+        from ansys.edb.core.simulation_setup.simulation_setup import (
+            FrequencyData as GrpcFrequencyData,
+        )
         from ansys.edb.core.simulation_setup.simulation_setup import (
             SweepData as GrpcSweepData,
         )
@@ -1267,7 +1273,10 @@ class Hfss(object):
         sweep_name = f"sweep_{len(setup.sweep_data) + 1}"
         sweep_data = [
             GrpcSweepData(
-                name=sweep_name, distribution=distribution, start_f=start_freq, end_f=stop_freq, step=step_freq
+                name=sweep_name,
+                frequency_data=GrpcFrequencyData(
+                    distribution=GrpcDistribution[distribution], start_f=start_freq, end_f=stop_freq, step=step_freq
+                ),
             )
         ]
         if discrete_sweep:

pyedb/grpc/database/layout_validation.py

@@ -284,9 +284,9 @@ class LayoutValidation:
             if prim.net_name in net_list:
                 new_prims.extend(prim.fix_self_intersections())
         if new_prims:
-            self._pedb._logger.info("Self-intersections detected and removed.")
+            self._pedb.logger.info("Self-intersections detected and removed.")
         else:
-            self._pedb._logger.info("Self-intersection not found.")
+            self._pedb.logger.info("Self-intersection not found.")
         return True
 
     def illegal_net_names(self, fix=False):

pyedb/grpc/database/padstacks.py

@@ -1569,14 +1569,13 @@ class Padstacks(object):
         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 net_filter:
-                instances = [self.instances[id] for id in instances if not self.instances[id].net.name in net_filter]
+                instances = [id for id in instances if not self.instances[id].net.name in net_filter]
             net = self.instances[instances[0]].net.name
-            instances_pts = np.array([self.instances[id].position for id in instances])
+            instances_pts = np.array([self.instances[inst].position for inst 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
@@ -1595,9 +1594,15 @@ class Padstacks(object):
                 stop_layer=stop_layer,
             ):
                 self._logger.error(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_via_ids.append(merged_instance.id)
-            [self.instances[id].delete() for id in instances]
+            merged_instance = self.place(
+                position=[0, 0],
+                definition_name=new_padstack_def,
+                net_name=net,
+                fromlayer=start_layer,
+                tolayer=stop_layer,
+            )
+            merged_via_ids.append(merged_instance.edb_uid)
+            [self.instances[inst].delete() for inst in instances]
         return merged_via_ids
 
     def reduce_via_in_bounding_box(self, bounding_box, x_samples, y_samples, nets=None):
@@ -1611,7 +1616,7 @@ class Padstacks(object):
         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
+            net name of list of nets name applying filtering on pad-stack instances selection. If ``None`` is provided
             all instances are included in the index. Default value is ``None``.
 
         Returns
@@ -1622,10 +1627,11 @@ class Padstacks(object):
 
         padstacks_inbox = self.get_padstack_instances_intersecting_bounding_box(bounding_box, nets)
         if not padstacks_inbox:
-            raise "No pad-stack in bounding box."
+            return False
         else:
             if len(padstacks_inbox) <= (x_samples * y_samples):
-                raise f"more samples {x_samples * y_samples} than existing {len(padstacks_inbox)}"
+                self._pedb.logger.error(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}

pyedb/grpc/database/ports/ports.py

@@ -146,7 +146,7 @@ class WavePort(EdgeTerminal):
     """
 
     def __init__(self, pedb, edb_terminal):
-        super().__init__(pedb, edb_terminal.msg)
+        super().__init__(pedb, edb_terminal)
 
     @property
     def horizontal_extent_factor(self):
@@ -161,9 +161,9 @@ class WavePort(EdgeTerminal):
 
     @horizontal_extent_factor.setter
     def horizontal_extent_factor(self, value):
-        self.p = p
-        p = self.p
+        p = self._hfss_port_property
         p["Horizontal Extent Factor"] = value
+        self._hfss_port_property = p
 
     @property
     def vertical_extent_factor(self):

pyedb/grpc/database/simulation_setup/hfss_simulation_setup.py

@@ -367,18 +367,23 @@ class HfssSimulationSetup(GrpcHfssSimulationSetup):
             start_freq = self._pedb.number_with_units(start_freq, "Hz")
             stop_freq = self._pedb.number_with_units(stop_freq, "Hz")
             step = str(step)
-            if distribution.lower() == "linear":
-                distribution = "LIN"
-            elif distribution.lower() == "linear_count":
-                distribution = "LINC"
-            elif distribution.lower() == "exponential":
-                distribution = "ESTP"
-            elif distribution.lower() == "decade_count":
-                distribution = "DEC"
-            elif distribution.lower() == "octave_count":
-                distribution = "OCT"
-            else:
-                distribution = "LIN"
+            if not distribution in ["LIN", "LINC", "ESTP", "DEC", "OCT"]:
+                if distribution.lower() == "linear" or distribution.lower() == "linear scale":
+                    distribution = "LIN"
+                elif distribution.lower() == "linear_count" or distribution.lower() == "linear count":
+                    distribution = "LINC"
+                elif distribution.lower() == "exponential":
+                    distribution = "ESTP"
+                elif (
+                    distribution.lower() == "decade_count"
+                    or distribution.lower() == "decade count"
+                    or distribution.lower()
+                ) == "log scale":
+                    distribution = "DEC"
+                elif distribution.lower() == "octave_count" or distribution.lower() == "octave count":
+                    distribution = "OCT"
+                else:
+                    distribution = "LIN"
             if not name:
                 name = f"sweep_{init_sweep_count + 1}"
             sweep_data = [
@@ -392,7 +397,7 @@ class HfssSimulationSetup(GrpcHfssSimulationSetup):
                 sweep_data.append(sweep)
             self.sweep_data = sweep_data
             if len(self.sweep_data) == init_sweep_count + 1:
-                return True
+                return self.sweep_data[-1]
             else:
                 self._pedb.logger.error("Failed to add frequency sweep data")
                 return False