pyedb 0.2.0__py3-none-any.whl

pyedb/generic/process.py

@@ -0,0 +1,285 @@
+import os.path
+
+from pyedb.generic.general_methods import env_path, is_ironpython, is_linux
+
+if is_linux and is_ironpython:
+    import subprocessdotnet as subprocess
+else:
+    import subprocess
+
+
+class SiwaveSolve(object):
+    def __init__(self, aedb_path="", aedt_version="2021.2", aedt_installer_path=None):
+        self._project_path = aedb_path
+        self._exec_path = ""
+        self._nbcores = 4
+        self._ng = True
+        if aedt_installer_path:
+            self.installer_path = aedt_installer_path
+        else:
+            try:
+                self.installer_path = env_path(aedt_version)
+            except:
+                raise Exception("Either a valid aedt version or full path has to be provided")
+        if self._ng:
+            executable = "siwave_ng"
+        else:
+            executable = "siwave"
+        if is_linux:
+            self._exe = os.path.join(self.installer_path, executable)
+        else:
+            self._exe = os.path.join(self.installer_path, executable + ".exe")
+
+    @property
+    def siwave_exe(self):
+        return self._exe
+
+    @siwave_exe.setter
+    def siwave_exe(self, value):
+        self._exe = value
+
+    @property
+    def projectpath(self):
+        return self._project_path
+
+    @projectpath.setter
+    def projectpath(self, value):
+        self._project_path = value
+
+    @property
+    def execfile(self):
+        return self._exec_path
+
+    @execfile.setter
+    def execfile(self, value):
+        self._exec_path = value
+
+    @property
+    def nbcores(self):
+        return self._nbcores
+
+    @nbcores.setter
+    def nbcores(self, value):
+        self._nbcores = value
+
+    @property
+    def nongraphical(self):
+        return self._ng
+
+    @nongraphical.setter
+    def nongraphical(self, value):
+        self._ng = value
+
+    def solve(self):
+        # supporting non graphical solve only
+        if self.nongraphical:
+            if is_linux:
+                exe_path = os.path.join(self.installer_path, "siwave_ng")
+            else:
+                exe_path = os.path.join(self.installer_path, "siwave_ng.exe")
+            exec_file = os.path.splitext(self._project_path)[0] + ".exec"
+            if os.path.exists(exec_file):
+                with open(exec_file, "r+") as f:
+                    content = f.readlines()
+                    if "SetNumCpus" not in content:
+                        f.writelines(str.format("SetNumCpus {}", str(self.nbcores)) + "\n")
+                        f.writelines("SaveSiw")
+                    else:
+                        fstarts = [i for i in range(len(content)) if content[i].startswith("SetNumCpus")]
+                        content[fstarts[0]] = str.format("SetNumCpus {}", str(self.nbcores))
+                        f.close()
+                        os.remove(exec_file)
+                        f = open(exec_file, "w")
+                        f.writelines(content)
+            command = [exe_path]
+            command.append(self._project_path)
+            command.append(exec_file)
+            command.append("-formatOutput -useSubdir")
+            p = subprocess.Popen(" ".join(command))
+            p.wait()
+
+    def export_3d_cad(
+        self, format_3d="Q3D", output_folder=None, net_list=None, num_cores=None, aedt_file_name=None, hidden=False
+    ):  # pragma: no cover
+        """Export edb to Q3D or HFSS
+
+        Parameters
+        ----------
+        format_3d : str, default ``Q3D``
+        output_folder : str
+            Output file folder. If `` then the aedb parent folder is used
+        net_list : list, default ``None``
+            Define Nets to Export. if None, all nets will be exported
+        num_cores : int, optional
+            Define number of cores to use during export
+        aedt_file_name : str, optional
+            Output  aedt file name (without .aedt extension). If `` then default naming is used
+        Returns
+        -------
+        str
+            path to aedt file
+        """
+        if not output_folder:
+            output_folder = os.path.dirname(self.projectpath)
+        scriptname = os.path.join(output_folder, "export_cad.py")
+        with open(scriptname, "w") as f:
+            f.write("import os\n")
+            f.write("edbpath = r'{}'\n".format(self.projectpath))
+            f.write("exportOptions = os.path.join(r'{}', 'options.config')\n".format(output_folder))
+            f.write("oDoc.ScrImportEDB(edbpath)\n")
+            f.write("oDoc.ScrSaveProjectAs(os.path.join(r'{}','{}'))\n".format(output_folder, "test.siw"))
+            if net_list:
+                f.write("allnets = []\n")
+                for el in net_list:
+                    f.write("allnets.append('{}')\n".format(el))
+                f.write("for i in range(0, len(allnets)):\n")
+                f.write("    if allnets[i] != 'DUMMY':\n")
+                f.write("        oDoc.ScrSelectNet(allnets[i], 1)\n")
+            f.write("oDoc.ScrSetOptionsFor3DModelExport(exportOptions)\n")
+            if not aedt_file_name:
+                aedt_file_name = format_3d + "_siwave.aedt"
+            f.write("q3d_filename = os.path.join(r'{}', '{}')\n".format(output_folder, aedt_file_name))
+            if num_cores:
+                f.write("oDoc.ScrSetNumCpusToUse('{}')\n".format(num_cores))
+                self.nbcores = num_cores
+            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") + '"'
+        command = [_exe]
+        if hidden:
+            command.append("-embedding")
+        command.append("-RunScriptAndExit")
+        command.append(scriptname)
+        print(command)
+        os.system(" ".join(command))
+        # p1 = subprocess.call(" ".join(command))
+        # p1.wait()
+        return os.path.join(output_folder, aedt_file_name)
+
+    def export_dc_report(
+        self,
+        siwave_project,
+        solution_name,
+        output_folder=None,
+        html_report=True,
+        vias=True,
+        voltage_probes=True,
+        current_sources=True,
+        voltage_sources=True,
+        power_tree=True,
+        loop_res=True,
+        hidden=True,
+    ):
+        """Close EDB and solve it with Siwave.
+
+        Parameters
+        ----------
+        siwave_project : str
+            Siwave full project name.
+        solution_name : str
+            Siwave DC Analysis name.
+        output_folder : str, optional
+            Ouptu folder where files will be downloaded.
+        html_report : bool, optional
+            Either if generate or not html report. Default is `True`.
+        vias : bool, optional
+            Either if generate or not vias report. Default is `True`.
+        voltage_probes : bool, optional
+            Either if generate or not voltage probe report. Default is `True`.
+        current_sources : bool, optional
+            Either if generate or not current source report. Default is `True`.
+        voltage_sources : bool, optional
+            Either if generate or not voltage source report. Default is `True`.
+        power_tree : bool, optional
+            Either if generate or not power tree image. Default is `True`.
+        loop_res : bool, optional
+            Either if generate or not loop resistance report. Default is `True`.
+
+        Returns
+        -------
+        list
+            list of files generated.
+        """
+        if not output_folder:
+            output_folder = os.path.dirname(self.projectpath)
+        output_list = []
+        scriptname = os.path.normpath(os.path.join(os.path.normpath(output_folder), "export_results.py"))
+        with open(scriptname, "w") as f:
+            f.write("oApp.OpenProject(r'{}')\n".format(siwave_project))
+            if html_report:
+                f.write("proj = oApp.GetActiveProject()\n")
+
+                f.write("proj.ScrExportDcSimReportColorBarProperties(14,2,False,True)\n")
+
+                f.write("proj.ScrExportDcSimReportScaling('All','All',-1,-1,False)\n")
+                report_name = os.path.join(output_folder, solution_name + ".htm")
+                f.write("proj.ScrExportDcSimReport('{}','White',r'{}')\n".format(solution_name, report_name))
+                output_list.append(report_name)
+            if vias:
+                via_name = os.path.join(output_folder, "vias.txt")
+                f.write("proj.ScrExportElementData('{}',r'{}','Vias')\n".format(solution_name, via_name))
+                output_list.append(via_name)
+
+            if voltage_probes:
+                probes_names = os.path.join(output_folder, "voltage_probes.txt")
+                f.write("proj.ScrExportElementData('{}',r'{}','Voltage Probes')\n".format(solution_name, probes_names))
+                output_list.append(probes_names)
+
+            if current_sources:
+                source_name = os.path.join(output_folder, "current_sources.txt")
+
+                f.write("proj.ScrExportElementData('{}',r'{}','Current Sources')\n".format(solution_name, source_name))
+                output_list.append(source_name)
+
+            if voltage_sources:
+                sources = os.path.join(output_folder, "v_sources.txt")
+
+                f.write("proj.ScrExportElementData('{}',r'{}','Voltage Sources')\n".format(solution_name, sources))
+                output_list.append(sources)
+
+            if power_tree:
+                csv_file = os.path.join(output_folder, "powertree.csv")
+                c = open(csv_file, "w")
+                c.close()
+                png_file = os.path.join(output_folder, "powertree.png")
+                f.write("proj.ScrExportDcPowerTree('{}',r'{}', r'{}' )\n".format(solution_name, csv_file, png_file))
+                output_list.append(png_file)
+
+            if loop_res:
+                f.write("sourceNames=[]\n")
+                f.write("sourceData=[]\n")
+                f.write("proj.ScrReadDCLoopResInfo('{}', sourceNames, sourceData)\n".format(solution_name))
+                loop_res = os.path.join(output_folder, "loop_res.txt")
+                f.write("with open(r'{}','w') as f:\n".format(loop_res))
+
+                f.write("  f.writelines('Sources\tValue\\n')\n")
+
+                f.write("  for a, b in zip(sourceNames, sourceData):\n")
+
+                f.write("      f.writelines(a + '\t' + b + '\\n')\n")
+                output_list.append(loop_res)
+
+            f.write("proj.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") + '"'
+        command = [_exe]
+        if hidden:
+            command.append("-embedding")
+        command.append("-RunScriptAndExit")
+        command.append('"' + scriptname + '"')
+        print(command)
+        if os.name == "posix":
+            p = subprocess.Popen(command)
+
+        else:
+            p = subprocess.Popen(" ".join(command))
+        p.wait()
+        return output_list

pyedb/generic/settings.py

@@ -0,0 +1,224 @@
+import logging
+import os
+import time
+
+
+class Settings(object):
+    """Manages all PyEDB environment variables and global settings."""
+
+    def __init__(self):
+        self.remote_rpc_session = False
+        self._enable_screen_logs = True
+        self._edb_dll_path = None
+        self._enable_logger = True
+        self._enable_file_logs = True
+        self.pyedb_server_path = ""
+        self._logger_file_path = None
+        self._logger_formatter = "%(asctime)s:%(destination)s:%(extra)s%(levelname)-8s:%(message)s"
+        self._logger_datefmt = "%Y/%m/%d %H.%M.%S"
+        self._enable_debug_edb_logger = False
+        self._enable_debug_grpc_api_logger = False
+        self._enable_debug_methods_argument_logger = False
+        self._enable_debug_geometry_operator_logger = False
+        self._enable_debug_internal_methods_logger = False
+        self._enable_debug_logger = False
+        self._enable_error_handler = True
+        self.formatter = None
+        self._project_properties = {}
+        self._project_time_stamp = 0
+        self._disable_bounding_box_sat = False
+        self._force_error_on_missing_project = False
+        self._enable_pandas_output = False
+        self.time_tick = time.time()
+        self._global_log_file_name = "pyedb_{}.log".format(os.path.split(os.path.expanduser("~"))[-1])
+        self._enable_global_log_file = True
+        self._enable_local_log_file = False
+        self._global_log_file_size = 10
+        self._lsf_queue = None
+        self._edb_environment_variables = {}
+
+    @property
+    def edb_environment_variables(self):
+        """Environment variables that are set before launching a new AEDT session,
+        including those that enable the beta features."""
+        return self._edb_environment_variables
+
+    @edb_environment_variables.setter
+    def edb_environment_variables(self, value):
+        self._edb_environment_variables = value
+
+    @property
+    def aedt_version(self):
+        """AEDT version in the form ``"2023.x"``. In AEDT 2022 R2 and later,
+        evaluating a bounding box by exporting a SAT file is disabled."""
+        return self._aedt_version
+
+    @aedt_version.setter
+    def aedt_version(self, value):
+        self._aedt_version = value
+        if self._aedt_version >= "2023.1":
+            self.disable_bounding_box_sat = True
+
+    @property
+    def global_log_file_size(self):
+        """Global PyEDB log file size in MB. The default value is ``10``."""
+        return self._global_log_file_size
+
+    @global_log_file_size.setter
+    def global_log_file_size(self, value):
+        self._global_log_file_size = value
+
+    @property
+    def enable_global_log_file(self):
+        """Flag for enabling and disabling the global PyEDB log file located in the global temp folder.
+        The default is ``True``."""
+        return self._enable_global_log_file
+
+    @enable_global_log_file.setter
+    def enable_global_log_file(self, value):
+        self._enable_global_log_file = value
+
+    @property
+    def enable_local_log_file(self):
+        """Flag for enabling and disabling the local PyEDB log file located
+        in the ``projectname.pyedb`` project folder. The default is ``True``."""
+        return self._enable_local_log_file
+
+    @enable_local_log_file.setter
+    def enable_local_log_file(self, value):
+        self._enable_local_log_file = value
+
+    @property
+    def global_log_file_name(self):
+        """Global PyEDB log file path. The default is ``pyedb_username.log``."""
+        return self._global_log_file_name
+
+    @global_log_file_name.setter
+    def global_log_file_name(self, value):
+        self._global_log_file_name = value
+
+    @property
+    def enable_debug_methods_argument_logger(self):
+        """Flag for whether to write out the method's arguments in the debug logger.
+        The default is ``False``."""
+        return self._enable_debug_methods_argument_logger
+
+    @enable_debug_methods_argument_logger.setter
+    def enable_debug_methods_argument_logger(self, val):
+        self._enable_debug_methods_argument_logger = val
+
+    @property
+    def logger(self):
+        """Active logger."""
+        try:
+            return logging.getLogger("Global")
+        except:  # pragma: no cover
+            return logging.getLogger(__name__)
+
+    @property
+    def enable_error_handler(self):
+        """Flag for enabling and disabling the internal PyEDB error handling."""
+        return self._enable_error_handler
+
+    @enable_error_handler.setter
+    def enable_error_handler(self, val):
+        self._enable_error_handler = val
+
+    @property
+    def enable_file_logs(self):
+        """Flag for enabling and disabling the logging to a file."""
+        return self._enable_file_logs
+
+    @enable_file_logs.setter
+    def enable_file_logs(self, val):
+        self._enable_file_logs = val
+
+    @property
+    def enable_logger(self):
+        """Flag for enabling and disabling the logging overall."""
+        return self._enable_logger
+
+    @enable_logger.setter
+    def enable_logger(self, val):
+        self._enable_logger = val
+
+    @property
+    def logger_file_path(self):
+        """PyEDB log file path."""
+        return self._logger_file_path
+
+    @logger_file_path.setter
+    def logger_file_path(self, val):
+        self._logger_file_path = val
+
+    @property
+    def logger_formatter(self):
+        """Message format of the log entries.
+        The default is ``'%(asctime)s:%(destination)s:%(extra)s%(levelname)-8s:%(message)s'``"""
+        return self._logger_formatter
+
+    @logger_formatter.setter
+    def logger_formatter(self, val):
+        self._logger_formatter = val
+
+    @property
+    def logger_datefmt(self):
+        """Date format of the log entries.
+        The default is ``'%Y/%m/%d %H.%M.%S'``"""
+        return self._logger_datefmt
+
+    @logger_datefmt.setter
+    def logger_datefmt(self, val):
+        self._logger_datefmt = val
+
+    @property
+    def enable_debug_edb_logger(self):
+        """Flag for enabling and disabling the logger for any EDB API methods."""
+        return self._enable_debug_edb_logger
+
+    @enable_debug_edb_logger.setter
+    def enable_debug_edb_logger(self, val):
+        self._enable_debug_edb_logger = val
+
+    @property
+    def enable_debug_internal_methods_logger(self):
+        """Flag for enabling and disabling the logging for internal methods.
+        This setting is useful for debug purposes."""
+        return self._enable_debug_internal_methods_logger
+
+    @enable_debug_internal_methods_logger.setter
+    def enable_debug_internal_methods_logger(self, val):
+        self._enable_debug_internal_methods_logger = val
+
+    @property
+    def enable_debug_logger(self):
+        """Flag for enabling and disabling the debug level logger."""
+        return self._enable_debug_logger
+
+    @enable_debug_logger.setter
+    def enable_debug_logger(self, val):
+        self._enable_debug_logger = val
+
+    # TODO: Not sure if needed, see with Simon
+    @property
+    def enable_screen_logs(self):
+        """Flag for enabling and disabling the logging to STDOUT."""
+        return self._enable_screen_logs
+
+    @enable_screen_logs.setter
+    def enable_screen_logs(self, val):
+        self._enable_screen_logs = val
+
+    # TODO: Not sure if needed, see with Simon
+    @property
+    def edb_dll_path(self):
+        """Optional path for the EDB DLL file."""
+        return self._edb_dll_path
+
+    @edb_dll_path.setter
+    def edb_dll_path(self, value):
+        if os.path.exists(value):
+            self._edb_dll_path = value
+
+
+settings = Settings()

pyedb/ipc2581/bom/bom.py

@@ -0,0 +1,21 @@
+from pyedb.generic.general_methods import ET
+
+
+class Bom(object):
+    def __init__(self, edb):
+        self._edb = edb
+        self.name = self._edb.cell_names[0]
+        self.revision = "1.0"
+        self.step_ref = "1.0"
+        self.bom_items = []
+
+    def write_xml(self, root):  # pragma no cover
+        bom = ET.SubElement(root, "Bom")
+        bom.set("name", self.name)
+        bom_header = ET.SubElement(bom, "BomHeader")
+        bom_header.set("assembly", self.name)
+        bom_header.set("revision", self.revision)
+        step_ref = ET.SubElement(bom_header, "StepRef")
+        step_ref.set("name", self.name)
+        for bom_item in self.bom_items:
+            bom_item.write_xml(bom)

pyedb/ipc2581/bom/bom_item.py

@@ -0,0 +1,32 @@
+from pyedb.generic.general_methods import ET
+from pyedb.ipc2581.bom.characteristics import Characteristics
+from pyedb.ipc2581.bom.refdes import RefDes
+
+
+class BomItem(object):
+    def __init__(self):
+        self.part_name = ""
+        self.quantity = "1"
+        self.pin_count = "1"
+        self.category = "ELECTRICAL"
+        self.refdes_list = []
+        self.charactistics = Characteristics()
+
+    def write_xml(self, bom):  # pragma no cover
+        bom_item = ET.SubElement(bom, "BomItem")
+        bom_item.set("OEMDesignNumberRef", self.part_name)
+        bom_item.set("quantity", str(self.quantity))
+        bom_item.set("pinCount", str(self.pin_count))
+        bom_item.set("category", self.category)
+        bom_item.set("category", self.category)
+        for refdes in self.refdes_list:
+            refdes.write_xml(bom_item)
+        self.charactistics.write_xml(bom_item)
+
+    def add_refdes(self, component_name=None, package_def=None, populate=True, placement_layer=""):  # pragma no cover
+        refdes = RefDes()
+        refdes.name = component_name
+        refdes.populate = str(populate)
+        refdes.packaged_def = package_def
+        refdes.placement_layer = placement_layer
+        self.refdes_list.append(refdes)

pyedb/ipc2581/bom/characteristics.py

@@ -0,0 +1,37 @@
+from pyedb.generic.general_methods import ET
+
+
+class Characteristics(object):
+    def __init__(self):
+        self.category = "ELECTRICAL"
+        self.device_type = ""
+        self.component_class = ""
+        self.value = ""
+
+    def write_xml(self, bom_item):  # pragma no cover
+        characteristic = ET.SubElement(bom_item, "Characteristics")
+        characteristic.set("category", self.category)
+        component_type = ET.SubElement(characteristic, "Textual")
+        component_type.set("definitionSource", "ANSYS")
+        component_type.set("textualCharacteristicName", "DEVICE_TYPE")
+        component_type.set("textualCharacteristicValue", "{}_{}".format(self.device_type, self.value))
+        component_class = ET.SubElement(characteristic, "Textual")
+        component_class.set("definitionSource", "ANSYS")
+        component_class.set("textualCharacteristicName", "COMP_CLASS")
+        component_class.set("textualCharacteristicValue", "{}".format(self.component_class))
+        component_value = ET.SubElement(characteristic, "Textual")
+        component_value.set("definitionSource", "ANSYS")
+        component_value.set("textualCharacteristicName", "VALUE")
+        component_value.set("textualCharacteristicValue", "{}".format(self.value))
+        component_parent_type = ET.SubElement(characteristic, "Textual")
+        component_parent_type.set("definitionSource", "ANSYS")
+        component_parent_type.set("textualCharacteristicName", "PARENT_PPT_PART")
+        component_parent_type.set("textualCharacteristicValue", "{}_{}".format(self.device_type, self.value))
+        component_parent = ET.SubElement(characteristic, "Textual")
+        component_parent.set("definitionSource", "ANSYS")
+        component_parent.set("textualCharacteristicName", "PARENT_PPT")
+        component_parent.set("textualCharacteristicValue", "{}".format(self.device_type))
+        component_parent2 = ET.SubElement(characteristic, "Textual")
+        component_parent2.set("definitionSource", "ANSYS")
+        component_parent2.set("textualCharacteristicName", "PARENT_PART_TYPE")
+        component_parent2.set("textualCharacteristicValue", "{}".format(self.device_type))

pyedb/ipc2581/bom/refdes.py

@@ -0,0 +1,16 @@
+from pyedb.generic.general_methods import ET
+
+
+class RefDes(object):
+    def __init__(self):
+        self.name = ""
+        self.packaged_def = ""
+        self.populate = "True"
+        self.placement_layer = ""
+
+    def write_xml(self, bom_item):  # pragma no cover
+        refdes = ET.SubElement(bom_item, "RefDes")
+        refdes.set("name", self.name)
+        refdes.set("packageRef", self.packaged_def)
+        refdes.set("populate", self.populate)
+        refdes.set("layerRef", self.placement_layer)

pyedb/ipc2581/content/color.py

@@ -0,0 +1,38 @@
+from pyedb.generic.general_methods import ET
+
+
+class Color(object):
+    def __init__(self):
+        self._r = 0
+        self._g = 0
+        self._b = 0
+
+    @property
+    def r(self):
+        return self._r
+
+    @r.setter
+    def r(self, value):
+        self._r = value
+
+    @property
+    def g(self):
+        return self._g
+
+    @g.setter
+    def g(self, value):
+        self._g = value
+
+    @property
+    def b(self):
+        return self._b
+
+    @b.setter
+    def b(self, value):
+        self._b = value
+
+    def write_xml(self, entry_color=None):  # pragma no cover
+        color = ET.SubElement(entry_color, "Color")
+        color.set("r", str(self.r))
+        color.set("g", str(self.g))
+        color.set("b", str(self.b))