setupEM 0.1.3__tar.gz → 0.1.4__tar.gz

{setupem-0.1.3 → setupem-0.1.4}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: setupEM
-Version: 0.1.3
+Version: 0.1.4
 Summary: Python tool for configuration of gds2palace workflow with GUI.
 Author-email: Volker Muehlhaus <volker@muehlhaus.com>
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: gds2palace>=0.1.2
+Requires-Dist: gds2palace>=0.1.4
 Requires-Dist: PySide6
+Requires-Dist: scipy
 
 # Create EM Simulation model from GDSII layout files
 

{setupem-0.1.3 → setupem-0.1.4}/pyproject.toml

@@ -4,15 +4,16 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "setupEM"
-version = "0.1.3"
+version = "0.1.4"
 description = "Python tool for configuration of gds2palace workflow with GUI."
 readme = "README.md"
 authors = [
     { name = "Volker Muehlhaus", email = "volker@muehlhaus.com" }
 ]
 dependencies = [
-    "gds2palace>=0.1.2",
-    "PySide6"
+    "gds2palace>=0.1.4",
+    "PySide6",
+    "scipy"
 ]
 requires-python = ">=3.9"
 

{setupem-0.1.3 → setupem-0.1.4}/src/setupEM/setupEM.py

@@ -17,15 +17,17 @@
 ########################################################################
 
 
-import sys, json, os, tempfile, pathlib, ast, webbrowser
+import sys, json, os, pathlib, ast, webbrowser
+import numpy as np
+from scipy.interpolate import interp1d
 from PySide6.QtWidgets import (
     QApplication, QMainWindow, QWidget, QHBoxLayout, QVBoxLayout,
     QLabel, QLineEdit,QComboBox,QTableWidget,QHeaderView,
     QPushButton, QFileDialog, QTabWidget, QMessageBox, QGroupBox,  
-    QCheckBox, QAbstractItemView,QStyleFactory,QTableWidgetItem, QPlainTextEdit    
+    QCheckBox, QAbstractItemView,QStyleFactory,QTableWidgetItem, QPlainTextEdit, QDialog    
     )
-from PySide6.QtGui import QAction, QColor, QTextCharFormat, QFont, QSyntaxHighlighter
-from PySide6.QtCore import Qt, QRegularExpression, QProcess
+from PySide6.QtGui import QAction, QColor, QTextCharFormat, QFont, QSyntaxHighlighter, QPainter, QPen
+from PySide6.QtCore import Qt, QRegularExpression, QProcess, QRect
 
 # we expect gds2palace in the same directory as this code, or installed as module
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), 'gds2palace')))
@@ -267,8 +269,16 @@ class FileInputTab(QWidget):
 
         self.XML_file_layout.addWidget(self.XML_file_edit)
         self.XML_file_layout.addWidget(self.browse_XML_btn)
-
         self.XML_layout.addLayout(self.XML_file_layout)
+
+        self.XML_show_layout = QHBoxLayout()
+        self.XML_show_layout.setAlignment(Qt.AlignRight)
+        self.show_XML_btn = QPushButton("Show Stackup")
+        self.show_XML_btn.setFixedWidth(150)
+        self.show_XML_btn.clicked.connect(self.MainWindow.open_popup)
+        self.XML_show_layout.addWidget(self.show_XML_btn)
+        self.XML_layout.addLayout(self.XML_show_layout)
+
         self.XML_group.setLayout(self.XML_layout)
 
         self.main_layout.addWidget(self.gds_group)
@@ -312,6 +322,7 @@ class FileInputTab(QWidget):
     def set_XML_file (self, filename):
         self.XML_file_edit.setText(filename)
         saved_values ["SubstrateFile"] = filename.replace('\\','/')
+        self.MainWindow.read_XML() # safe if invalid filename
         # file is read when leaving the files tab
 
 
@@ -330,22 +341,11 @@ class FileInputTab(QWidget):
         # read_XML(self.XML_file_edit.text()) # safe if invalid filename
 
 
-    # load technology stackup data
-    def read_XML(self, filename):
-        if pathlib.Path(filename).exists():
-            materials_list, dielectrics_list, metals_list = stackup_reader.read_substrate (filename)
-            self.MainWindow.ports_tab.update_layers(metals_list)
-
-
-
     def save_values(self):
         saved_values ["GdsFile"] = self.gds_file_edit.text().replace('\\','/')
         saved_values ["SubstrateFile"] = self.XML_file_edit.text().replace('\\','/')
         saved_values ["preprocess_gds"] = self.preprocess_gds_checkbox.isChecked()
         
-        # read Substrate file, which also updates port target layer choices
-        self.read_XML(saved_values ["SubstrateFile"])
-        
         try:
             merge_polygon_size = float(self.viamerge_edit.text())
         except Exception:
@@ -365,6 +365,9 @@ class FileInputTab(QWidget):
         # also trigger the load function of CreateModelTab, because that uses gds file info
         self.MainWindow.create_model_tab.load_values()
 
+        # read Substrate file, which also updates port target layer choices
+        self.MainWindow.read_XML()
+
         return True  # Tab change only possible when returning True
         
 
@@ -1660,7 +1663,7 @@ class ModelEditorTab(QWidget):
                 "\n\tpurposelist=settings['purpose'], "
                 "\n\tmetals_list=metals_list, \n\tpreprocess=settings['preprocess_gds'], "
                 "\n\tmerge_polygon_size=settings['merge_polygon_size']," 
-                "\n\tgds_boundary_layers=[],"
+                "\n\tgds_boundary_layers=dielectrics_list.get_boundary_layers(),"
                 "\n\tmirror=False, "
                 "\n\toffset_x=0, offset_y=0,"
                 "\n\tlayernumber_offset=0)")
@@ -1778,6 +1781,327 @@ class CodeEditor(QPlainTextEdit):
         self.setLineWrapMode(QPlainTextEdit.NoWrap)
 
 
+# ---------- POP UP WINDOW TO SHOW STACKUP ------------------
+
+def epsilon_to_color(erel, transparency):
+    # Compute raw float components
+    red   = 250 - 30 * (erel - 1)
+    green = 255 - 20 * (erel - 1) + (20 / erel) + 10 * erel
+    blue  = 100 + 15 * erel + (250 / erel)
+
+    # Extra adjustment 
+    if 3.8 < erel < 4.5:
+        red   += 50 * (erel - 3.8)
+        green -= 100 * (erel - 3.8)
+
+    # Clamp to range 0–255
+    red   = min(max(red,   0), 255)
+    green = min(max(green, 0), 255)
+    blue  = min(max(blue,  0), 255)
+
+    # Convert to integer RGB
+    r = int(round(red))
+    g = int(round(green))
+    b = int(round(blue))
+
+    return QColor(r, g, b, transparency)
+
+
+class VectorWidget(QWidget):
+    """This widget actually draws the stackup preview"""
+
+    def __init__(self, materials_list,dielectrics_list,metals_list): 
+        super().__init__()
+        self.materials_list = materials_list
+        self.dielectrics_list = dielectrics_list
+        self.metals_list = metals_list
+
+
+    def paintEvent(self, event):
+
+        # utility: flip y to have y=0 at bottom
+        def flipy(y):
+            return self.height()-y
+
+        # utility to draw text with alignment on right side
+        def drawText_right (x, y, w, h, text):
+            rect = QRect(x, y-h, w, h)
+            painter.drawText(rect, Qt.AlignVCenter | Qt.AlignRight, text)
+
+        def drawText_left (x, y, w, h, text):
+            rect = QRect(x, y-h, w, h)
+            painter.drawText(rect, Qt.AlignVCenter | Qt.AlignLeft, text)
+
+        painter = QPainter(self)
+        painter.fillRect(self.rect(), Qt.white)
+        painter.setRenderHint(QPainter.Antialiasing)
+        
+        xmin = int(self.width()*0.02)
+        xmax = int(self.width()*0.98)
+
+        ymin = int(self.height()*0.025)
+        ymax = int(self.height()*0.975)
+
+        penBlack = QPen(Qt.black, 1)
+        penGray  = QPen(QColor(134, 132, 130))
+        penDarkGray = QPen(QColor(53, 50, 47))
+
+        # get total dielectric parts, where each metal in a dielectric adds one part 
+        dielectric_shapes = []
+        total_parts = 0
+        dielectrics_bottom_up = self.dielectrics_list.dielectrics[::-1]
+        for dielectric in dielectrics_bottom_up: # bottom up
+            painter.setPen(penBlack)
+
+            metals_inside = dielectric.get_planar_metals_inside()
+            # get number of unique zmin values in that list
+            zmin_list = []
+            for metal in metals_inside:
+                if not metal.zmin in zmin_list:
+                    zmin_list.append(metal.zmin)
+            metals_count = len(zmin_list)
+
+            # first metal not aligned with dielectric?
+            if len(metals_inside)>0:
+                if metals_inside[0].zmin > dielectric.zmin:
+                    metals_count = metals_count+ 0.5
+
+            parts = max (1,metals_count)
+            dielectric_shape = {}
+            dielectric_shape['name'] = dielectric.name
+            dielectric_shape['dielectric'] = dielectric
+            dielectric_shape['numparts'] = parts
+
+            # dielectric color is calculated from permittivity
+            materialname = dielectric.material
+            material = self.materials_list.get_by_name(materialname)
+            eps = material.eps
+            dielectric_shape['color'] =  epsilon_to_color(eps, 95) # QColor(Qt.white) 
+            dielectric_shape['material'] = material
+         
+            total_parts = total_parts + parts
+            dielectric_shapes.append(dielectric_shape)
+
+        # calculate height of one dielectric shape
+        total_parts = max(total_parts, 1)
+        part_height = int((ymax-ymin)/(total_parts))
+
+        y = ymin
+        w = xmax-ymin
+
+        # we need to store data for original z position and the displayed y position 
+        stored_z = np.array([0])
+        stored_y = np.array([0])
+
+
+        for dielectric_shape in dielectric_shapes:
+            h = part_height * dielectric_shape['numparts']
+            dielectric = dielectric_shape['dielectric']
+            color = dielectric_shape['color']
+            material = dielectric_shape['material']
+            
+            material_string  = f'εr={material.eps:.1f}'
+            if material.sigma > 1e-3:
+                material_string = material_string + f' σ={material.sigma:.1f}'
+            material_string = material_string + f'\n{dielectric.thickness:.2f}µm'
+
+            painter.setPen(penBlack)
+            painter.setBrush(color)
+            painter.drawRect(xmin, flipy(y), w, -h)   
+            drawText_left  (xmin+5, flipy(y), w, h, dielectric.name)   
+            drawText_right (xmin, flipy(y), w-5, h, material_string)   
+
+            if not dielectric.zmax in stored_z:
+                stored_z = np.append(stored_z, dielectric.zmax)
+                stored_y = np.append(stored_y, y+h)
+
+
+            # get metals inside this dielectric 
+            metals_inside = dielectric.get_planar_metals_inside()
+            # height for one dielectric segment including one metal is part_height
+            if len(metals_inside) > 0:
+
+                # there could be multiple metals starting at the same zmin
+
+                # draw planar metals, one after another
+                ymetal = y
+                for n, metal in enumerate(metals_inside):
+                    
+                    painter.setPen(penBlack)
+
+                    # check if metal is aligned with dielectric zmin
+                    elevation = metal.zmin-dielectric.zmin
+                    if n==0 and (abs(elevation) > 0.001):
+                        # draw some vertical offset, not aligned with dielectric
+                        ymetal = ymetal + part_height*0.5 # slight offset
+
+                    # check if next metal is at same zmin
+                    next_at_same_zmin = False
+                    previous_at_same_zmin = False
+                    xmetal = xmin+120
+                    wmetal = w-200
+
+                    if n < len(metals_inside)-1:
+                        next_metal = metals_inside[n+1]
+                        if abs(next_metal.zmin - metal.zmin) < 0.001:
+                            next_at_same_zmin = True
+                            xmetal = xmin+120
+                            wmetal = int(w/2)-100
+                    else:
+                        next_metal = None        
+                    
+                    if n > 0:
+                        previous_metal = metals_inside[n-1]
+                        if abs(previous_metal.zmin - metal.zmin) < 0.001:
+                            xmetal = xmin+int(w/2)+20
+                            wmetal = int(w/2)-100
+                            previous_at_same_zmin = True
+                   
+                    material = self.materials_list.get_by_name(metal.material)
+
+                    if metal.is_sheet:
+                        # sheet metal that is simulated with zero extrusion
+                        height = 3
+                        resistance_string = f'Rs={material.Rs*1e3:.1f}mΩ'
+                    else:  
+                        # regular extruded metal
+                        height = part_height/2
+                        if (material.sigma > 0) and (metal.thickness > 0):
+                            Rs = 1 / (material.sigma*metal.thickness*1e-6)
+                            if Rs < 1:
+                                resistance_string = f'Rs={Rs*1e3:.1f} mΩ'
+                            else:    
+                                resistance_string = f'Rs={Rs:.2f} Ω'
+                        else:
+                            resistance_string = '? ' + material.type + ' ?'        
+
+                    # the box for this metal
+                    if material.type.upper() == "CONDUCTOR":
+                        painter.setBrush(QColor(230,230,230, 90))
+                        painter.drawRect(xmetal, flipy(ymetal), wmetal, -int(height))
+                    else:    
+                        painter.setBrush(QColor(230,130,130, 90))
+                        painter.drawRect(xmetal, flipy(ymetal), wmetal, -int(height))
+                    
+                    painter.setPen(penBlack)
+                    drawText_left(xmetal+10, flipy(ymetal), wmetal, part_height/2, metal.name)   
+                    painter.setPen(penGray)
+                    drawText_right(xmetal, flipy(ymetal), wmetal-10, part_height/2, resistance_string)   
+                    # store the drawing position, because vias will refer to that
+                    if not metal.zmin in stored_z:
+                        stored_z = np.append(stored_z, metal.zmin)
+                        stored_y = np.append(stored_y, ymetal)
+                    if not metal.zmax in stored_z:
+                        stored_z = np.append(stored_z, metal.zmax)
+                        stored_y = np.append(stored_y, ymetal+height)
+
+                    painter.setPen(penGray)
+                    painter.drawLine(xmetal-60, flipy(ymetal), xmetal-10, flipy(ymetal))
+                    # draw line at top side of metal
+                    if not metal.is_sheet:
+                        painter.drawLine(xmetal-60, flipy(ymetal+height), xmetal-10, flipy(ymetal+height))
+                        heightstring = f'{metal.thickness:.3f}µm'
+                        painter.setPen(penDarkGray)
+                        drawText_left(xmetal-60,  flipy(ymetal), 50, height, heightstring)
+
+
+                    if not previous_at_same_zmin:
+                        # draw height to metal above
+                        if next_metal is not None:
+                            dz = abs(next_metal.zmin - metal.zmax)
+                            heightstring = f'{dz:.3f}µm'
+                            painter.setPen(penGray)
+                            drawText_left(xmetal-60,  flipy(ymetal+height), 50, height, heightstring)
+
+                    if n==len(metals_inside)-1:
+                        # last metal (top metal)
+                        # place text for distance to dielectric boundary
+                    
+                        painter.setPen(penBlack)
+                        dz = dielectric.zmax - metal.zmax
+                        if dz > 10:
+                            heightstring = f'{dz:.1f}µm'
+                        else:    
+                            heightstring = f'{dz:.3f}µm'
+                        painter.setPen(penGray)
+                        painter.drawText(xmetal-60,  flipy(ymetal+height+5), heightstring)
+                    
+                    if n==0 and elevation > 0.001:
+                        # metal not aligned with bottom of dielectric, add a label for offset value
+                        heightstring = f'{elevation:.3f}µm'
+                        painter.setPen(penGray)
+                        painter.drawText(xmetal-60,  flipy(ymetal-10), heightstring)
+
+
+                    if not next_at_same_zmin:
+                        # increase screen y for next metal
+                        ymetal = ymetal + part_height
+
+            y = y + h        
+
+        # sort stored positions
+        if len(stored_z) > 2: 
+            idx = np.argsort(stored_z)
+            y_sorted = stored_y[idx]
+            z_sorted = stored_z[idx]
+            z_to_y = interp1d(z_sorted, y_sorted, kind='cubic', fill_value='extrapolate')
+
+            # next we draw the vias, based on the screen position of metals that we have stored
+            # via position alternates between 3 positions along x axis 
+            pos = 1        
+            w = (xmax-xmin)/10
+
+            painter.setBrush(QColor(136,192,200,80))
+            for metal in self.metals_list.metals:
+                if metal.is_via:
+                    y1 = z_to_y(metal.zmin)
+                    y2 = z_to_y(metal.zmax)
+                    h  = abs(y2-y1)
+
+                    if pos == 1:
+                        xvia = (xmax+xmin)/2-4*w/2
+                        pos = 2
+                    elif pos == 2:
+                        xvia = (xmax+xmin)/2-w/2
+                        pos = 3
+                    else:
+                        xvia = (xmax+xmin)/2+w
+                        pos = 1
+
+                    painter.setPen(penBlack)
+                    painter.drawRect(xvia, flipy(y1), w, -h)
+                    painter.drawText(xvia+10, flipy(y1+5), metal.name)   
+
+        painter.end()
+
+
+class PopUpWindow(QDialog):
+    """This window shows the substrate stackup preview"""
+    def __init__(self, MainWindow):
+        super().__init__()
+        self.setAttribute(Qt.WA_DeleteOnClose)
+        self.setWindowTitle("Stackup Preview")
+        self.resize(700, 800)
+        self.MainWindow = MainWindow
+
+        layout = QVBoxLayout()
+
+        # Add the custom painting widget
+        self.vector_widget = VectorWidget(self.MainWindow.materials_list, 
+                                          self.MainWindow.dielectrics_list, 
+                                          self.MainWindow.metals_list)
+        layout.addWidget(self.vector_widget)
+
+        # Close button
+        close_button = QPushButton("Close")
+        close_button.clicked.connect(self.close)
+        layout.addWidget(close_button)
+
+        self.setLayout(layout)
+        self.setModal(True)
+
+
+
 # ---------- MAIN WINDOW ----------
 
 
@@ -1822,6 +2146,11 @@ class MainWindow(QMainWindow):
         self.tabs_widget.currentChanged.connect(self.on_tab_change)
         main_layout.addWidget(self.tabs_widget)
 
+        # Stackup data from XML, used when showing stackup viewer
+        self.materials_list = None
+        self.dielectrics_list = None
+        self.metals_list = None
+
         # Do not auto-load default values at this early startup stage, 
         # instead this is done from File menu
         # self.user_inputs_file = DEFAULT_SETTINGS_FILE
@@ -1950,7 +2279,6 @@ class MainWindow(QMainWindow):
             self.load_configuration_from_file(file_path)
 
 
-
     def load_configuration_from_file(self, file_path):
         if file_path:
             extension = pathlib.Path(file_path).suffix
@@ -2134,6 +2462,20 @@ class MainWindow(QMainWindow):
             saved_values['sim_path']=''
 
 
+    # load technology stackup data
+    def read_XML(self):
+        filename = saved_values ["SubstrateFile"]
+        if pathlib.Path(filename).exists():
+            self.materials_list, self.dielectrics_list, self.metals_list = stackup_reader.read_substrate (filename)
+            self.ports_tab.update_layers(self.metals_list)
+
+
+    def open_popup(self):
+        # self.read_XML(saved_values ["SubstrateFile"])
+        self.popup = PopUpWindow(self)
+        self.popup.show()
+
+
 
 def parse_assignments(file_path):
     # parse lines from a Python model code for variable assigments
@@ -2206,6 +2548,8 @@ def main():
 
     win = MainWindow()
     win.show()
+
+    
     sys.exit(app.exec())
 
 if __name__ == "__main__":

{setupem-0.1.3 → setupem-0.1.4}/src/setupEM.egg-info/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: setupEM
-Version: 0.1.3
+Version: 0.1.4
 Summary: Python tool for configuration of gds2palace workflow with GUI.
 Author-email: Volker Muehlhaus <volker@muehlhaus.com>
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: gds2palace>=0.1.2
+Requires-Dist: gds2palace>=0.1.4
 Requires-Dist: PySide6
+Requires-Dist: scipy
 
 # Create EM Simulation model from GDSII layout files
 

setupem-0.1.4/src/setupEM.egg-info/requires.txt

@@ -0,0 +1,3 @@
+gds2palace>=0.1.4
+PySide6
+scipy

setupem-0.1.3/src/setupEM.egg-info/requires.txt

@@ -1,2 +0,0 @@
-gds2palace>=0.1.2
-PySide6